A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.
feat(desktop): self-update appimages in place (#2843)
Hampusc4f0b2ece027
diff --git a/fluxer_app/src/features/app/state/Updater.ts b/fluxer_app/src/features/app/state/Updater.tsindex 9aacd4358..0db69c209 100644--- a/fluxer_app/src/features/app/state/Updater.ts+++ b/fluxer_app/src/features/app/state/Updater.ts@@ -696,10 +696,14 @@ class Updater {} finally {this.transition({type: 'manualDownload.finished'});}- await this.downloadManualNativeUpdateOrOpen(currentOption.url, currentOption.suggestedName);+ await this.downloadManualNativeUpdateOrOpen(currentOption.url, currentOption.suggestedName, currentOption.sha256);}- private async downloadManualNativeUpdateOrOpen(url: string, suggestedName?: string): Promise<void> {+ private async downloadManualNativeUpdateOrOpen(+ url: string,+ suggestedName?: string,+ sha256?: string | null,+ ): Promise<void> {if (this.manualNativeDownloadInFlight) {return;}@@ -708,10 +712,16 @@ class Updater {const outcome = await downloadWithNative({url,suggestedName: suggestedName ?? this.getManualUpdateSuggestedName(url),+ sha256,});if (outcome === 'success' || outcome === 'canceled') {return;}+ if (outcome === 'checksum-mismatch') {+ logger.error('Native manual update download did not match its published checksum', {url});+ pushDesktopUpdateDownloadFailedModal();+ return;+ }logger.warn('Native manual update download unavailable; opening update URL externally', {outcome});await openExternalUrl(url);} finally {diff --git a/fluxer_app/src/features/app/utils/UpdaterPlatformUtils.ts b/fluxer_app/src/features/app/utils/UpdaterPlatformUtils.tsindex dc300dcfb..ab3c9e6ce 100644--- a/fluxer_app/src/features/app/utils/UpdaterPlatformUtils.ts+++ b/fluxer_app/src/features/app/utils/UpdaterPlatformUtils.ts@@ -5,5 +5,5 @@ export function shouldShowNativeDesktopUpdateInApp(platform: string | null | und}export function shouldShowNativeDesktopUpdateDownloadProgress(platform: string | null | undefined): boolean {- return platform === 'win32';+ return platform === 'win32' || platform === 'linux';}diff --git a/fluxer_app/src/features/platform/types/Electron.ts b/fluxer_app/src/features/platform/types/Electron.tsindex 376c78051..42bbee6b3 100644--- a/fluxer_app/src/features/platform/types/Electron.ts+++ b/fluxer_app/src/features/platform/types/Electron.ts@@ -212,6 +212,7 @@ export interface DownloadFileOptions {export interface DownloadFileResult {success: boolean;canceled?: boolean;+ checksumMismatch?: boolean;path?: string;error?: string;}@@ -357,7 +358,7 @@ export interface ElectronAPI {requestInputMonitoringPermission?: () => Promise<InputMonitoringPermissionStatus>;getScreenRecordingPermissionStatus?: () => Promise<InputMonitoringPermissionStatus>;requestScreenRecordingPermission?: () => Promise<InputMonitoringPermissionStatus>;- downloadFile: (url: string, defaultPath: string) => Promise<DownloadFileResult>;+ downloadFile: (url: string, defaultPath: string, sha256?: string | null) => Promise<DownloadFileResult>;toggleDevTools: () => void;showNotification: (options: NotificationOptions) => Promise<NotificationResult>;shouldPlayNotificationSound?: () => Promise<boolean>;diff --git a/fluxer_app/src/features/ui/utils/NativeUtils.ts b/fluxer_app/src/features/ui/utils/NativeUtils.tsindex c1be6bc6a..78eeb7011 100644--- a/fluxer_app/src/features/ui/utils/NativeUtils.ts+++ b/fluxer_app/src/features/ui/utils/NativeUtils.ts@@ -273,21 +273,27 @@ export function attachExternalLinkInterceptor() {};}-export type NativeDownloadOutcome = 'success' | 'canceled' | 'failed' | 'unavailable';+export type NativeDownloadOutcome = 'success' | 'canceled' | 'checksum-mismatch' | 'failed' | 'unavailable';export async function downloadWithNative(options: {url: string;suggestedName?: string;title?: string;+ sha256?: string | null;}): Promise<NativeDownloadOutcome> {const electronApi = getElectronAPI();if (!electronApi) {return 'unavailable';}try {- const result = await electronApi.downloadFile(options.url, options.suggestedName ?? 'download');+ const result = await electronApi.downloadFile(+ options.url,+ options.suggestedName ?? 'download',+ options.sha256 ?? null,+ );if (result.success) return 'success';if (result.canceled) return 'canceled';+ if (result.checksumMismatch) return 'checksum-mismatch';return 'failed';} catch (error) {logger.error(' Native download failed, falling back to browser', error);diff --git a/fluxer_app/src/types/electron.d.ts b/fluxer_app/src/types/electron.d.tsindex bcea5d108..97409dcac 100644--- a/fluxer_app/src/types/electron.d.ts+++ b/fluxer_app/src/types/electron.d.ts@@ -283,6 +283,7 @@ export interface UpdaterDownloadOption {export interface DownloadResult {success: boolean;canceled?: boolean;+ checksumMismatch?: boolean;path?: string;error?: string;}@@ -349,7 +350,7 @@ export interface ElectronAPI {platform: 'darwin' | 'win32' | 'linux' | string;buildChannel: 'stable' | 'canary';openExternal(url: string): Promise<void>;- downloadFile(url: string, suggestedName: string): Promise<DownloadResult>;+ downloadFile(url: string, suggestedName: string, sha256?: string | null): Promise<DownloadResult>;onUpdaterEvent(callback: (event: UpdaterEvent) => void): () => void;updaterCheck(context: 'user' | 'background'): Promise<void>;updaterDownload(context: 'user' | 'background'): Promise<void>;diff --git a/fluxer_desktop/src/common/Types.ts b/fluxer_desktop/src/common/Types.tsindex a642e85a7..4f8a16e9b 100644--- a/fluxer_desktop/src/common/Types.ts+++ b/fluxer_desktop/src/common/Types.ts@@ -246,6 +246,7 @@ export type UpdaterEvent =export interface DownloadFileResult {success: boolean;canceled?: boolean;+ checksumMismatch?: boolean;path?: string;error?: string;}@@ -697,7 +698,7 @@ export interface ElectronAPI {requestInputMonitoringPermission: () => Promise<InputMonitoringPermissionStatus>;getScreenRecordingPermissionStatus: () => Promise<InputMonitoringPermissionStatus>;requestScreenRecordingPermission: () => Promise<InputMonitoringPermissionStatus>;- downloadFile: (url: string, defaultPath: string) => Promise<DownloadFileResult>;+ downloadFile: (url: string, defaultPath: string, sha256?: string | null) => Promise<DownloadFileResult>;toggleDevTools: () => void;showNotification: (options: NotificationOptions) => Promise<NotificationResult>;shouldPlayNotificationSound: () => Promise<boolean>;diff --git a/fluxer_desktop/src/main/AppImageUpdate.test.mjs b/fluxer_desktop/src/main/AppImageUpdate.test.mjsnew file mode 100644index 000000000..f58d49a6b--- /dev/null+++ b/fluxer_desktop/src/main/AppImageUpdate.test.mjs@@ -0,0 +1,694 @@+// SPDX-License-Identifier: AGPL-3.0-or-later++import assert from 'node:assert/strict';+import {createHash} from 'node:crypto';+import {+ chmodSync,+ existsSync,+ mkdirSync,+ mkdtempSync,+ readdirSync,+ readFileSync,+ statSync,+ symlinkSync,+ writeFileSync,+} from 'node:fs';+import {createServer} from 'node:http';+import {createRequire} from 'node:module';+import {tmpdir} from 'node:os';+import {join} from 'node:path';+import {after, before, 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('./AppImageUpdate.ts', import.meta.url));+const source = readFileSync(sourcePath, 'utf8');+const transformedSource = esbuild.transformSync(source, {+ loader: 'ts',+ format: 'cjs',+ platform: 'node',+ target: 'node20',+}).code;++function loadAppImageUpdate(env = {}, overrides = {}, requireImpl = require) {+ const module = {exports: {}};+ const context = vm.createContext({+ module,+ exports: module.exports,+ require: requireImpl,+ console,+ Buffer,+ fetch,+ Error,+ Number,+ process: {...process, ...overrides, env: {...env}},+ });+ vm.runInContext(transformedSource, context, {filename: sourcePath});+ return module.exports;+}++const INSTALLED_NAME = 'My Fluxer.AppImage';+const OLD_BYTES = Buffer.from('old-appimage-payload');+const NEW_BYTES = Buffer.alloc(400_000, 7);+const NEW_SHA256 = createHash('sha256').update(NEW_BYTES).digest('hex');++let server;+let baseUrl;+let requestCount = 0;++before(async () => {+ server = createServer((request, response) => {+ requestCount += 1;+ if (request.url === '/appimage') {+ response.writeHead(200, {'content-type': 'application/octet-stream', 'content-length': NEW_BYTES.length});+ response.end(NEW_BYTES);+ return;+ }+ if (request.url === '/corrupt') {+ const corrupt = Buffer.from(NEW_BYTES);+ corrupt[0] = corrupt[0] ^ 0xff;+ response.writeHead(200, {'content-type': 'application/octet-stream', 'content-length': corrupt.length});+ response.end(corrupt);+ return;+ }+ response.writeHead(404);+ response.end('missing');+ });+ await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));+ baseUrl = `http://127.0.0.1:${server.address().port}`;+});++after(async () => {+ await new Promise((resolve) => server.close(resolve));+});++function createInstall() {+ const root = mkdtempSync(join(tmpdir(), 'fluxer-appimage-test-'));+ const applications = join(root, 'Applications');+ mkdirSync(applications);+ const installedPath = join(applications, INSTALLED_NAME);+ writeFileSync(installedPath, OLD_BYTES, {mode: 0o755});+ return {root, applications, installedPath};+}++function stagingLeftovers(directory) {+ return readdirSync(directory).filter((entry) => entry.startsWith('.fluxer-update-'));+}++function assertUnavailable(result, reason) {+ assert.equal(result.ok, false);+ assert.equal(result.reason, reason);+}++function createAppDir(name) {+ const root = mkdtempSync(join(tmpdir(), 'fluxer-appdir-test-'));+ const dir = join(root, name);+ mkdirSync(dir);+ writeFileSync(join(dir, 'AppRun'), '#!/usr/bin/env bash\n', {mode: 0o755});+ const binary = join(dir, 'fluxer-canary');+ writeFileSync(binary, 'elf', {mode: 0o755});+ return {dir, binary};+}++function stagingPrefixFor(installedPath) {+ return `.fluxer-update-${createHash('sha256').update(installedPath).digest('hex').slice(0, 8)}-`;+}++describe('AppImageUpdate process provenance', () => {+ test('accepts the process the AppImage runtime execed out of its own mount', () => {+ const {isRunningFromAppImage} = loadAppImageUpdate({});+ const mounted = createAppDir('.mount_My FluAKcenK');++ assert.equal(isRunningFromAppImage({APPDIR: mounted.dir}, mounted.binary), true);+ assert.equal(isRunningFromAppImage({APPDIR: `${mounted.dir}/`}, mounted.binary), true);+ assert.equal(isRunningFromAppImage({APPDIR: mounted.dir}, join(mounted.dir, 'usr', 'bin', 'fluxer-canary')), true);+ });++ test('refuses an extracted AppDir, whose APPIMAGE belongs to whatever launched it', () => {+ const {isRunningFromAppImage} = loadAppImageUpdate({});+ const extracted = createAppDir('squashfs-root');+ const launcher = createAppDir('.mount_My FluOjOANH');++ assert.equal(isRunningFromAppImage({}, extracted.binary), false);+ assert.equal(+ isRunningFromAppImage({APPDIR: launcher.dir}, extracted.binary),+ false,+ 'the generated AppRun assigns APPDIR without exporting it, so an APPDIR that reaches this process and does not contain it came from another AppImage',+ );+ });++ test('refuses an installed package that inherited APPIMAGE from the terminal it was started in', () => {+ const {isRunningFromAppImage} = loadAppImageUpdate({});+ const terminal = createAppDir('.mount_Alacritty7fJk2L');++ assert.equal(isRunningFromAppImage({}, '/opt/Fluxer/fluxer'), false);+ assert.equal(isRunningFromAppImage({APPDIR: ''}, '/opt/Fluxer/fluxer'), false);+ assert.equal(isRunningFromAppImage({APPDIR: terminal.dir}, '/opt/Fluxer/fluxer'), false);+ });++ test('refuses a mount path that only prefixes this executable', () => {+ const {isRunningFromAppImage} = loadAppImageUpdate({});+ const mounted = createAppDir('.mount_My FluAKcenK');++ assert.equal(isRunningFromAppImage({APPDIR: mounted.dir}, `${mounted.dir}-other/fluxer-canary`), false);+ });++ test('refuses an APPDIR the runtime cannot have mounted', () => {+ const {isRunningFromAppImage} = loadAppImageUpdate({});+ const installDir = mkdtempSync(join(tmpdir(), 'fluxer-opt-test-'));+ const binary = join(installDir, 'fluxer-canary');+ writeFileSync(binary, 'elf', {mode: 0o755});++ assert.equal(isRunningFromAppImage({APPDIR: installDir}, binary), false);+ writeFileSync(join(installDir, 'AppRun'), '#!/usr/bin/env bash\n', {mode: 0o755});+ assert.equal(isRunningFromAppImage({APPDIR: installDir}, binary), true);+ });+});++describe('AppImageUpdate target resolution', () => {+ test('falls back when APPIMAGE is unset', () => {+ const {resolveAppImageTarget} = loadAppImageUpdate({});++ assertUnavailable(resolveAppImageTarget(), 'appimage-path-missing');+ assertUnavailable(resolveAppImageTarget(''), 'appimage-path-missing');+ assertUnavailable(resolveAppImageTarget(' '), 'appimage-path-missing');+ });++ test('falls back when the AppImage moved since launch', () => {+ const install = createInstall();+ const {resolveAppImageTarget} = loadAppImageUpdate({APPIMAGE: join(install.applications, 'Gone.AppImage')});++ assertUnavailable(resolveAppImageTarget(), 'appimage-path-gone');+ });++ test('falls back when the path is not a regular file', () => {+ const install = createInstall();+ const {resolveAppImageTarget} = loadAppImageUpdate({APPIMAGE: install.applications});++ assertUnavailable(resolveAppImageTarget(), 'appimage-path-not-a-file');+ });++ test('falls back when the containing directory is not writable', {skip: process.getuid?.() === 0}, () => {+ const install = createInstall();+ chmodSync(install.applications, 0o500);+ try {+ const {resolveAppImageTarget} = loadAppImageUpdate({APPIMAGE: install.installedPath});++ assertUnavailable(resolveAppImageTarget(), 'directory-not-writable');+ } finally {+ chmodSync(install.applications, 0o755);+ }+ });++ test('resolves a writable AppImage to its own path', () => {+ const install = createInstall();+ const {resolveAppImageTarget} = loadAppImageUpdate({APPIMAGE: install.installedPath});++ const resolved = resolveAppImageTarget();+ assert.equal(resolved.ok, true);+ assert.equal(resolved.target.installedPath, install.installedPath);+ assert.equal(resolved.target.directory, install.applications);+ });+});++describe('AppImageUpdate in-place replacement', () => {+ test('replaces the running AppImage and keeps the user filename', async () => {+ const install = createInstall();+ const appImageUpdate = loadAppImageUpdate({APPIMAGE: install.installedPath});+ const resolved = appImageUpdate.resolveAppImageTarget();+ assert.equal(resolved.ok, true);++ const progress = [];+ const staged = await appImageUpdate.stageAppImageUpdate({+ target: resolved.target,+ url: `${baseUrl}/appimage`,+ expectedSha256: NEW_SHA256,+ onProgress: (sample) => progress.push(sample),+ });++ assert.equal(staged.stagedPath, join(staged.stagingDirectory, INSTALLED_NAME));+ assert.equal(readFileSync(install.installedPath).equals(OLD_BYTES), true);+ assert.ok(progress.length > 0);+ assert.equal(progress.at(-1).transferred, NEW_BYTES.length);+ assert.equal(progress.at(-1).total, NEW_BYTES.length);++ appImageUpdate.applyStagedAppImageUpdate(resolved.target, staged);++ assert.deepEqual(readdirSync(install.applications), [INSTALLED_NAME]);+ assert.equal(readFileSync(install.installedPath).equals(NEW_BYTES), true);+ assert.equal(createHash('sha256').update(readFileSync(install.installedPath)).digest('hex'), NEW_SHA256);+ assert.equal(statSync(install.installedPath).mode & 0o111, 0o111);+ });++ test('stages inside the install directory so the rename cannot cross filesystems', async () => {+ const install = createInstall();+ const appImageUpdate = loadAppImageUpdate({APPIMAGE: install.installedPath});+ const resolved = appImageUpdate.resolveAppImageTarget();++ const staged = await appImageUpdate.stageAppImageUpdate({+ target: resolved.target,+ url: `${baseUrl}/appimage`,+ expectedSha256: NEW_SHA256,+ });++ assert.equal(staged.stagingDirectory.startsWith(join(install.applications, '.fluxer-update-')), true);+ appImageUpdate.discardStagedAppImageUpdate(staged);+ assert.deepEqual(stagingLeftovers(install.applications), []);+ });++ test('refuses to swap when the download does not match the published checksum', async () => {+ const install = createInstall();+ const appImageUpdate = loadAppImageUpdate({APPIMAGE: install.installedPath});+ const resolved = appImageUpdate.resolveAppImageTarget();++ await assert.rejects(+ appImageUpdate.stageAppImageUpdate({+ target: resolved.target,+ url: `${baseUrl}/corrupt`,+ expectedSha256: NEW_SHA256,+ }),+ (error) => {+ assert.equal(error instanceof appImageUpdate.AppImageChecksumError, true);+ assert.match(error.message, /checksum mismatch/);+ return true;+ },+ );++ assert.equal(readFileSync(install.installedPath).equals(OLD_BYTES), true);+ assert.deepEqual(readdirSync(install.applications), [INSTALLED_NAME]);+ });++ test('refuses a checksum the release feed never published', async () => {+ const install = createInstall();+ const appImageUpdate = loadAppImageUpdate({APPIMAGE: install.installedPath});+ const resolved = appImageUpdate.resolveAppImageTarget();+ const before = requestCount;++ await assert.rejects(+ appImageUpdate.stageAppImageUpdate({+ target: resolved.target,+ url: `${baseUrl}/appimage`,+ expectedSha256: '',+ }),+ /checksum is missing or malformed/,+ );++ assert.equal(requestCount, before);+ assert.deepEqual(readdirSync(install.applications), [INSTALLED_NAME]);+ });++ test('cleans up and leaves the install untouched when the download fails', async () => {+ const install = createInstall();+ const appImageUpdate = loadAppImageUpdate({APPIMAGE: install.installedPath});+ const resolved = appImageUpdate.resolveAppImageTarget();++ await assert.rejects(+ appImageUpdate.stageAppImageUpdate({+ target: resolved.target,+ url: `${baseUrl}/nothing-here`,+ expectedSha256: NEW_SHA256,+ }),+ /Update download failed: 404/,+ );++ assert.equal(readFileSync(install.installedPath).equals(OLD_BYTES), true);+ assert.deepEqual(readdirSync(install.applications), [INSTALLED_NAME]);+ });++ test('finishes a short write instead of installing a truncated AppImage', async () => {+ const install = createInstall();+ let shortWrites = 0;+ const shortWritingRequire = (specifier) => {+ const real = require(specifier);+ if (specifier !== 'node:fs/promises') {+ return real;+ }+ return {+ ...real,+ open: async (...args) => {+ const handle = await real.open(...args);+ return {+ close: () => handle.close(),+ datasync: () => handle.datasync(),+ write: (buffer, offset, length) => {+ const capped = shortWrites === 0 ? Math.min(length, 4096) : length;+ shortWrites += 1;+ return handle.write(buffer, offset, capped);+ },+ };+ },+ };+ };+ const appImageUpdate = loadAppImageUpdate({APPIMAGE: install.installedPath}, {}, shortWritingRequire);+ const resolved = appImageUpdate.resolveAppImageTarget();++ const staged = await appImageUpdate.stageAppImageUpdate({+ target: resolved.target,+ url: `${baseUrl}/appimage`,+ expectedSha256: NEW_SHA256,+ });++ assert.ok(shortWrites > 1, 'the write loop has to come back for the remainder of a short write');+ assert.equal(statSync(staged.stagedPath).size, NEW_BYTES.length);+ assert.equal(createHash('sha256').update(readFileSync(staged.stagedPath)).digest('hex'), NEW_SHA256);+ appImageUpdate.discardStagedAppImageUpdate(staged);+ });++ test('checksums the staged file from disk, not the stream it was read from', async () => {+ const install = createInstall();+ const droppingRequire = (specifier) => {+ const real = require(specifier);+ if (specifier !== 'node:fs/promises') {+ return real;+ }+ return {+ ...real,+ open: async (...args) => {+ const handle = await real.open(...args);+ return {+ close: () => handle.close(),+ datasync: () => handle.datasync(),+ write: async (buffer, offset, length) => {+ const kept = Math.max(0, length - 1024);+ if (kept > 0) {+ await handle.write(buffer, offset, kept);+ }+ return {bytesWritten: length};+ },+ };+ },+ };+ };+ const appImageUpdate = loadAppImageUpdate({APPIMAGE: install.installedPath}, {}, droppingRequire);+ const resolved = appImageUpdate.resolveAppImageTarget();++ await assert.rejects(+ appImageUpdate.stageAppImageUpdate({+ target: resolved.target,+ url: `${baseUrl}/appimage`,+ expectedSha256: NEW_SHA256,+ }),+ (error) => {+ assert.equal(error instanceof appImageUpdate.AppImageChecksumError, true);+ return true;+ },+ );++ assert.equal(readFileSync(install.installedPath).equals(OLD_BYTES), true);+ assert.deepEqual(readdirSync(install.applications), [INSTALLED_NAME]);+ });++ test('flushes the staged file to disk before it can be renamed over the install', async () => {+ const install = createInstall();+ let flushes = 0;+ const countingRequire = (specifier) => {+ const real = require(specifier);+ if (specifier !== 'node:fs/promises') {+ return real;+ }+ return {+ ...real,+ open: async (...args) => {+ const handle = await real.open(...args);+ return {+ close: () => handle.close(),+ datasync: () => {+ flushes += 1;+ return handle.datasync();+ },+ write: (buffer, offset, length) => handle.write(buffer, offset, length),+ };+ },+ };+ };+ const appImageUpdate = loadAppImageUpdate({APPIMAGE: install.installedPath}, {}, countingRequire);+ const resolved = appImageUpdate.resolveAppImageTarget();++ const staged = await appImageUpdate.stageAppImageUpdate({+ target: resolved.target,+ url: `${baseUrl}/appimage`,+ expectedSha256: NEW_SHA256,+ });++ assert.equal(flushes, 1);+ appImageUpdate.discardStagedAppImageUpdate(staged);+ });++ test('gives up when the staged bytes cannot be flushed to disk', async () => {+ const install = createInstall();+ const failingFlushRequire = (specifier) => {+ const real = require(specifier);+ if (specifier !== 'node:fs/promises') {+ return real;+ }+ return {+ ...real,+ open: async (...args) => {+ const handle = await real.open(...args);+ return {+ close: () => handle.close(),+ datasync: async () => {+ const error = new Error('ENOSPC: no space left on device, fsync');+ error.code = 'ENOSPC';+ throw error;+ },+ write: (buffer, offset, length) => handle.write(buffer, offset, length),+ };+ },+ };+ };+ const appImageUpdate = loadAppImageUpdate({APPIMAGE: install.installedPath}, {}, failingFlushRequire);+ const resolved = appImageUpdate.resolveAppImageTarget();++ await assert.rejects(+ appImageUpdate.stageAppImageUpdate({+ target: resolved.target,+ url: `${baseUrl}/appimage`,+ expectedSha256: NEW_SHA256,+ }),+ (error) => {+ assert.equal(error instanceof appImageUpdate.AppImageStagingError, true);+ assert.equal(error.code, 'ENOSPC');+ return true;+ },+ );++ assert.deepEqual(readdirSync(install.applications), [INSTALLED_NAME]);+ });++ test('retries a body that stops short of content-length instead of calling it a bad build', async () => {+ const install = createInstall();+ const appImageUpdate = loadAppImageUpdate({APPIMAGE: install.installedPath});+ const resolved = appImageUpdate.resolveAppImageTarget();+ const truncatingFetch = async () => {+ let sent = false;+ return {+ ok: true,+ status: 200,+ headers: {get: (name) => (name === 'content-length' ? String(NEW_BYTES.length) : null)},+ body: {+ cancel: async () => {},+ getReader: () => ({+ cancel: async () => {},+ read: async () => {+ if (sent) {+ return {done: true, value: undefined};+ }+ sent = true;+ return {done: false, value: NEW_BYTES.subarray(0, 1024)};+ },+ }),+ },+ };+ };++ await assert.rejects(+ appImageUpdate.stageAppImageUpdate({+ target: resolved.target,+ url: `${baseUrl}/appimage`,+ expectedSha256: NEW_SHA256,+ fetchImpl: truncatingFetch,+ }),+ (error) => {+ assert.equal(error instanceof appImageUpdate.AppImageChecksumError, false);+ assert.equal(error instanceof appImageUpdate.AppImageStagingError, false);+ assert.match(error.message, new RegExp(`ended after 1024 of ${NEW_BYTES.length} bytes`));+ return true;+ },+ );++ assert.deepEqual(readdirSync(install.applications), [INSTALLED_NAME]);+ });++ test('refuses to stage when the install filesystem cannot hold the download', async () => {+ const install = createInstall();+ const appImageUpdate = loadAppImageUpdate({APPIMAGE: install.installedPath});+ const resolved = appImageUpdate.resolveAppImageTarget();+ const hugeFetch = async () => ({+ ok: true,+ status: 200,+ headers: {get: (name) => (name === 'content-length' ? String(Number.MAX_SAFE_INTEGER) : null)},+ body: {+ cancel: async () => {},+ getReader: () => ({cancel: async () => {}, read: async () => ({done: true, value: undefined})}),+ },+ });++ await assert.rejects(+ appImageUpdate.stageAppImageUpdate({+ target: resolved.target,+ url: `${baseUrl}/appimage`,+ expectedSha256: NEW_SHA256,+ fetchImpl: hugeFetch,+ }),+ (error) => {+ assert.equal(error instanceof appImageUpdate.AppImageStagingError, true);+ assert.equal(error.code, 'ENOSPC');+ return true;+ },+ );++ assert.deepEqual(readdirSync(install.applications), [INSTALLED_NAME]);+ });++ test('marks a local write failure as non-retryable', async () => {+ const install = createInstall();+ const appImageUpdate = loadAppImageUpdate({APPIMAGE: install.installedPath});+ const resolved = appImageUpdate.resolveAppImageTarget();+ const failingFetch = async () => ({+ ok: true,+ status: 200,+ headers: {get: () => null},+ body: {+ cancel: async () => {},+ getReader: () => ({+ cancel: async () => {},+ read: async () => {+ const error = new Error('ENOSPC: no space left on device, write');+ error.code = 'ENOSPC';+ throw error;+ },+ }),+ },+ });++ await assert.rejects(+ appImageUpdate.stageAppImageUpdate({+ target: resolved.target,+ url: `${baseUrl}/appimage`,+ expectedSha256: NEW_SHA256,+ fetchImpl: failingFetch,+ }),+ (error) => {+ assert.equal(error instanceof appImageUpdate.AppImageStagingError, true);+ assert.equal(error.code, 'ENOSPC');+ return true;+ },+ );++ assert.deepEqual(readdirSync(install.applications), [INSTALLED_NAME]);+ });++ test('refuses to install when the AppImage moved between download and install', async () => {+ const install = createInstall();+ const appImageUpdate = loadAppImageUpdate({APPIMAGE: install.installedPath});+ const resolved = appImageUpdate.resolveAppImageTarget();+ const staged = await appImageUpdate.stageAppImageUpdate({+ target: resolved.target,+ url: `${baseUrl}/appimage`,+ expectedSha256: NEW_SHA256,+ });++ const relocated = {installedPath: join(install.applications, 'Moved.AppImage'), directory: install.applications};+ assert.throws(+ () => appImageUpdate.applyStagedAppImageUpdate(relocated, staged),+ /cannot be replaced in place: appimage-path-gone/,+ );++ assert.equal(readFileSync(install.installedPath).equals(OLD_BYTES), true);+ assert.deepEqual(stagingLeftovers(install.applications), []);+ });+});++describe('AppImageUpdate abandoned staging cleanup', () => {+ test('reclaims staged updates left behind by a process that never quit cleanly', async () => {+ const install = createInstall();+ const appImageUpdate = loadAppImageUpdate({APPIMAGE: install.installedPath});+ const resolved = appImageUpdate.resolveAppImageTarget();+ const abandoned = await appImageUpdate.stageAppImageUpdate({+ target: resolved.target,+ url: `${baseUrl}/appimage`,+ expectedSha256: NEW_SHA256,+ });++ assert.equal(stagingLeftovers(install.applications).length, 1);++ const reclaimed = appImageUpdate.sweepAbandonedAppImageUpdates(resolved.target);++ assert.deepEqual([...reclaimed], [abandoned.stagingDirectory]);+ assert.deepEqual(readdirSync(install.applications), [INSTALLED_NAME]);+ assert.equal(readFileSync(install.installedPath).equals(OLD_BYTES), true);+ });++ test('leaves a staged update belonging to another AppImage in the same directory alone', async () => {+ const install = createInstall();+ const siblingPath = join(install.applications, 'Fluxer Canary.AppImage');+ writeFileSync(siblingPath, OLD_BYTES, {mode: 0o755});+ const appImageUpdate = loadAppImageUpdate({APPIMAGE: install.installedPath});+ const resolved = appImageUpdate.resolveAppImageTarget();+ const sibling = appImageUpdate.resolveAppImageTarget(siblingPath);+ const siblingStaged = await appImageUpdate.stageAppImageUpdate({+ target: sibling.target,+ url: `${baseUrl}/appimage`,+ expectedSha256: NEW_SHA256,+ });++ const reclaimed = appImageUpdate.sweepAbandonedAppImageUpdates(resolved.target);++ assert.deepEqual([...reclaimed], []);+ assert.equal(existsSync(siblingStaged.stagedPath), true);+ appImageUpdate.discardStagedAppImageUpdate(siblingStaged);+ assert.deepEqual(stagingLeftovers(install.applications), []);+ });++ test('unlinks a staging-named symlink instead of following it out of the install directory', () => {+ const install = createInstall();+ const outside = mkdtempSync(join(tmpdir(), 'fluxer-outside-test-'));+ writeFileSync(join(outside, 'keep-me'), 'not ours to delete');+ const planted = join(install.applications, `${stagingPrefixFor(install.installedPath)}link`);+ symlinkSync(outside, planted);+ const appImageUpdate = loadAppImageUpdate({APPIMAGE: install.installedPath});+ const resolved = appImageUpdate.resolveAppImageTarget();++ const reclaimed = appImageUpdate.sweepAbandonedAppImageUpdates(resolved.target);++ assert.deepEqual([...reclaimed], [planted]);+ assert.deepEqual(readdirSync(install.applications), [INSTALLED_NAME]);+ assert.deepEqual(readdirSync(outside), ['keep-me']);+ });++ test('leaves everything that is not one of this AppImage staging directories alone', () => {+ const install = createInstall();+ const neighbours = ['Fluxer Canary.AppImage', '.fluxer-update-notes.txt', '.fluxer-update-'];+ for (const name of neighbours) {+ writeFileSync(join(install.applications, name), 'keep');+ }+ const appImageUpdate = loadAppImageUpdate({APPIMAGE: install.installedPath});+ const resolved = appImageUpdate.resolveAppImageTarget();++ assert.deepEqual([...appImageUpdate.sweepAbandonedAppImageUpdates(resolved.target)], []);+ assert.deepEqual(readdirSync(install.applications).sort(), [...neighbours, INSTALLED_NAME].sort());+ });++ test('reports nothing when the install directory holds no staged update', () => {+ const install = createInstall();+ const appImageUpdate = loadAppImageUpdate({APPIMAGE: install.installedPath});+ const resolved = appImageUpdate.resolveAppImageTarget();++ assert.deepEqual([...appImageUpdate.sweepAbandonedAppImageUpdates(resolved.target)], []);+ assert.deepEqual(readdirSync(install.applications), [INSTALLED_NAME]);+ });+});diff --git a/fluxer_desktop/src/main/AppImageUpdate.ts b/fluxer_desktop/src/main/AppImageUpdate.tsnew file mode 100644index 000000000..c181cf8f5--- /dev/null+++ b/fluxer_desktop/src/main/AppImageUpdate.ts@@ -0,0 +1,272 @@+// SPDX-License-Identifier: AGPL-3.0-or-later++import {createHash} from 'node:crypto';+import {+ accessSync,+ chmodSync,+ constants,+ createReadStream,+ existsSync,+ mkdtempSync,+ readdirSync,+ renameSync,+ rmSync,+ statfsSync,+ statSync,+} from 'node:fs';+import {open} from 'node:fs/promises';+import {basename, dirname, join, resolve, sep} from 'node:path';++type AppImageUnavailableReason =+ | 'appimage-path-missing'+ | 'appimage-path-gone'+ | 'appimage-path-not-a-file'+ | 'directory-not-writable';++export type AppImageTarget = {+ installedPath: string;+ directory: string;+};++type AppImageTargetResult = {ok: true; target: AppImageTarget} | {ok: false; reason: AppImageUnavailableReason};++export type StagedAppImageUpdate = {+ stagedPath: string;+ stagingDirectory: string;+};++type AppImageDownloadProgress = {+ transferred: number;+ total: number;+};++const STAGING_DIRECTORY_PREFIX = '.fluxer-update-';+const APPDIR_ENTRYPOINT = 'AppRun';+const APPIMAGE_MODE = 0o755;+const SHA256_PATTERN = /^[0-9a-f]{64}$/;+const STAGING_FREE_SPACE_MARGIN_BYTES = 16 * 1024 * 1024;+const NON_RETRYABLE_STAGING_ERRNOS = new Set([+ 'ENOSPC',+ 'EDQUOT',+ 'EROFS',+ 'EACCES',+ 'EPERM',+ 'EIO',+ 'EMFILE',+ 'EINVAL',+ 'ENOSYS',+]);++export class AppImageChecksumError extends Error {+ constructor(expected: string, actual: string) {+ super(`Update checksum mismatch: expected ${expected}, downloaded ${actual}`);+ this.name = 'AppImageChecksumError';+ }+}++export class AppImageStagingError extends Error {+ readonly code: string;++ constructor(code: string, message: string) {+ super(message);+ this.name = 'AppImageStagingError';+ this.code = code;+ }+}++function errnoCode(error: unknown): string | null {+ if (error !== null && typeof error === 'object' && 'code' in error) {+ const code = (error as {code?: unknown}).code;+ if (typeof code === 'string') {+ return code;+ }+ }+ return null;+}++function asStagingError(error: unknown): unknown {+ const code = errnoCode(error);+ if (code === null || !NON_RETRYABLE_STAGING_ERRNOS.has(code)) {+ return error;+ }+ return new AppImageStagingError(code, error instanceof Error ? error.message : String(error));+}++function stagingDirectoryPrefix(installedPath: string): string {+ const scope = createHash('sha256').update(installedPath).digest('hex').slice(0, 8);+ return `${STAGING_DIRECTORY_PREFIX}${scope}-`;+}++export function isRunningFromAppImage(env: NodeJS.ProcessEnv = process.env, execPath = process.execPath): boolean {+ const appDir = env.APPDIR;+ if (typeof appDir !== 'string' || appDir.trim().length === 0) {+ return false;+ }+ const mounted = resolve(appDir.trim());+ const running = resolve(execPath);+ if (running !== mounted && !running.startsWith(`${mounted}${sep}`)) {+ return false;+ }+ return existsSync(join(mounted, APPDIR_ENTRYPOINT));+}++export function resolveAppImageTarget(appImagePath = process.env.APPIMAGE): AppImageTargetResult {+ if (typeof appImagePath !== 'string' || appImagePath.trim().length === 0) {+ return {ok: false, reason: 'appimage-path-missing'};+ }+ let stats: ReturnType<typeof statSync>;+ try {+ stats = statSync(appImagePath);+ } catch {+ return {ok: false, reason: 'appimage-path-gone'};+ }+ if (!stats.isFile()) {+ return {ok: false, reason: 'appimage-path-not-a-file'};+ }+ const directory = dirname(appImagePath);+ try {+ accessSync(directory, constants.W_OK | constants.X_OK);+ } catch {+ return {ok: false, reason: 'directory-not-writable'};+ }+ return {ok: true, target: {installedPath: appImagePath, directory}};+}++function assertRoomToStage(directory: string, total: number): void {+ if (total <= 0) {+ return;+ }+ let available: number;+ try {+ const stats = statfsSync(directory);+ available = Number(stats.bavail) * Number(stats.bsize);+ } catch {+ return;+ }+ if (!Number.isFinite(available) || available >= total + STAGING_FREE_SPACE_MARGIN_BYTES) {+ return;+ }+ throw new AppImageStagingError(+ 'ENOSPC',+ `Not enough free space in ${directory} to stage the update: ${available} bytes available, ${total} bytes needed.`,+ );+}++async function digestFile(path: string): Promise<string> {+ const hash = createHash('sha256');+ const stream = createReadStream(path);+ for await (const chunk of stream) {+ hash.update(chunk as Buffer);+ }+ return hash.digest('hex');+}++export async function stageAppImageUpdate(options: {+ target: AppImageTarget;+ url: string;+ expectedSha256: string;+ onProgress?: (progress: AppImageDownloadProgress) => void;+ fetchImpl?: typeof fetch;+}): Promise<StagedAppImageUpdate> {+ const expected = options.expectedSha256.trim().toLowerCase();+ if (!SHA256_PATTERN.test(expected)) {+ throw new Error('Update checksum is missing or malformed.');+ }+ const fetchImpl = options.fetchImpl ?? fetch;+ const response = await fetchImpl(options.url, {cache: 'no-store', redirect: 'follow'});+ if (!response.ok || response.body == null) {+ throw new Error(`Update download failed: ${response.status}`);+ }+ const declaredTotal = Number.parseInt(response.headers.get('content-length') ?? '', 10);+ const total = Number.isFinite(declaredTotal) && declaredTotal > 0 ? declaredTotal : 0;+ try {+ assertRoomToStage(options.target.directory, total);+ } catch (error) {+ await response.body.cancel().catch(() => {});+ throw error;+ }+ let stagingDirectory: string;+ try {+ stagingDirectory = mkdtempSync(+ join(options.target.directory, stagingDirectoryPrefix(options.target.installedPath)),+ );+ } catch (error) {+ await response.body.cancel().catch(() => {});+ throw asStagingError(error);+ }+ const staged: StagedAppImageUpdate = {+ stagedPath: join(stagingDirectory, basename(options.target.installedPath)),+ stagingDirectory,+ };+ try {+ const handle = await open(staged.stagedPath, 'wx', APPIMAGE_MODE);+ const reader = response.body.getReader();+ let transferred = 0;+ try {+ for (;;) {+ const {done, value} = await reader.read();+ if (done) {+ break;+ }+ let written = 0;+ while (written < value.byteLength) {+ const result = await handle.write(value, written, value.byteLength - written);+ if (result.bytesWritten <= 0) {+ throw new AppImageStagingError('ENOSPC', `Staging write stalled after ${transferred} bytes.`);+ }+ written += result.bytesWritten;+ transferred += result.bytesWritten;+ }+ options.onProgress?.({transferred, total});+ }+ if (total > 0 && transferred < total) {+ throw new Error(`Update download ended after ${transferred} of ${total} bytes.`);+ }+ await handle.datasync();+ } catch (error) {+ await reader.cancel().catch(() => {});+ throw error;+ } finally {+ await handle.close();+ }+ const digest = await digestFile(staged.stagedPath);+ if (digest !== expected) {+ throw new AppImageChecksumError(expected, digest);+ }+ chmodSync(staged.stagedPath, APPIMAGE_MODE);+ return staged;+ } catch (error) {+ discardStagedAppImageUpdate(staged);+ throw asStagingError(error);+ }+}++export function applyStagedAppImageUpdate(target: AppImageTarget, staged: StagedAppImageUpdate): void {+ const resolved = resolveAppImageTarget(target.installedPath);+ if (!resolved.ok) {+ discardStagedAppImageUpdate(staged);+ throw new Error(`AppImage cannot be replaced in place: ${resolved.reason}`);+ }+ renameSync(staged.stagedPath, target.installedPath);+ discardStagedAppImageUpdate(staged);+}++export function discardStagedAppImageUpdate(staged: StagedAppImageUpdate): void {+ try {+ rmSync(staged.stagingDirectory, {recursive: true, force: true});+ } catch {}+}++export function sweepAbandonedAppImageUpdates(target: AppImageTarget): Array<string> {+ const prefix = stagingDirectoryPrefix(target.installedPath);+ const reclaimed: Array<string> = [];+ for (const entry of readdirSync(target.directory)) {+ if (!entry.startsWith(prefix)) {+ continue;+ }+ const abandoned = join(target.directory, entry);+ rmSync(abandoned, {recursive: true, force: true});+ reclaimed.push(abandoned);+ }+ return reclaimed;+}diff --git a/fluxer_desktop/src/main/DesktopTray.ts b/fluxer_desktop/src/main/DesktopTray.tsindex 57df8e379..17d5ef76f 100644--- a/fluxer_desktop/src/main/DesktopTray.ts+++ b/fluxer_desktop/src/main/DesktopTray.ts@@ -11,7 +11,7 @@ import type {TrayActionPayload,TrayRuntimeStatePayload,} from '@electron/common/Types';-import {getStableRelaunchOptions} from '@electron/main/LinuxLaunchPath';+import {relaunchStableLaunchPath} from '@electron/main/LinuxLaunchPath';import {onLocaleChange, t} from '@electron/main/MainI18n';import {app, type BrowserWindow, clipboard, Menu, nativeImage, Tray} from 'electron';@@ -277,7 +277,7 @@ function restartFromTray(): void {trayRestartRequested = true;controller?.setQuitting(true);destroyDesktopTray();- app.relaunch(getStableRelaunchOptions());+ relaunchStableLaunchPath();app.quit();armTrayForcedExit('restart');}diff --git a/fluxer_desktop/src/main/FileDownloads.test.mjs b/fluxer_desktop/src/main/FileDownloads.test.mjsnew file mode 100644index 000000000..a092929e2--- /dev/null+++ b/fluxer_desktop/src/main/FileDownloads.test.mjs@@ -0,0 +1,201 @@+// SPDX-License-Identifier: AGPL-3.0-or-later++import assert from 'node:assert/strict';+import {createHash} from 'node:crypto';+import {existsSync, mkdtempSync, readFileSync, writeFileSync} from 'node:fs';+import {createServer} from 'node:http';+import {createRequire} from 'node:module';+import {tmpdir} from 'node:os';+import {join} from 'node:path';+import {after, before, 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');++function transform(name) {+ const url = new URL(`./${name}`, import.meta.url);+ const path = fileURLToPath(url);+ return {+ path,+ code: esbuild.transformSync(readFileSync(path, 'utf8'), {+ loader: 'ts',+ format: 'cjs',+ platform: 'node',+ target: 'node20',+ define: {'import.meta.url': JSON.stringify(url.href)},+ }).code,+ };+}++const outboundSource = transform('DesktopOutboundHTTP.ts');+const fileDownloadsSource = transform('FileDownloads.ts');++const PAYLOAD = Buffer.alloc(300_000, 9);+const PAYLOAD_SHA256 = createHash('sha256').update(PAYLOAD).digest('hex');+const CORRUPT = Buffer.concat([Buffer.from([0]), PAYLOAD.subarray(1)]);+const CORRUPT_SHA256 = createHash('sha256').update(CORRUPT).digest('hex');+const EMPTY_SHA256 = createHash('sha256').digest('hex');++let server;+let baseUrl;+let requests = 0;++before(async () => {+ server = createServer((request, response) => {+ requests += 1;+ if (request.url === '/payload' || request.url === '/redirected') {+ response.writeHead(200, {'content-type': 'application/octet-stream', 'content-length': PAYLOAD.length});+ response.end(PAYLOAD);+ return;+ }+ if (request.url === '/corrupt') {+ response.writeHead(200, {'content-type': 'application/octet-stream', 'content-length': CORRUPT.length});+ response.end(CORRUPT);+ return;+ }+ if (request.url === '/redirect') {+ response.writeHead(302, {location: '/redirected'});+ response.end();+ return;+ }+ if (request.url === '/empty') {+ response.writeHead(204);+ response.end();+ return;+ }+ response.writeHead(404);+ response.end('missing');+ });+ await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));+ baseUrl = `http://127.0.0.1:${server.address().port}`;+});++after(async () => {+ await new Promise((resolve) => server.close(resolve));+});++function loadFileDownloads() {+ const stubs = {+ '@electron/common/DesktopConfig': {getAppUrl: () => baseUrl},+ '@electron/common/Logger': {+ createChildLogger: () => ({debug() {}, info() {}, warn() {}, error() {}}),+ },+ };+ const sandbox = {+ console,+ Buffer,+ URL,+ process,+ setTimeout,+ clearTimeout,+ require: (specifier) => stubs[specifier] ?? require(specifier),+ };+ const context = vm.createContext(sandbox);++ const outboundModule = {exports: {}};+ sandbox.module = outboundModule;+ sandbox.exports = outboundModule.exports;+ vm.runInContext(outboundSource.code, context, {filename: outboundSource.path});+ stubs['@electron/main/DesktopOutboundHTTP'] = outboundModule.exports;++ const fileDownloadsModule = {exports: {}};+ sandbox.module = fileDownloadsModule;+ sandbox.exports = fileDownloadsModule.exports;+ vm.runInContext(fileDownloadsSource.code, context, {filename: fileDownloadsSource.path});+ return fileDownloadsModule.exports;+}++function destination() {+ return join(mkdtempSync(join(tmpdir(), 'fluxer-download-test-')), 'Fluxer-linux-amd64.deb');+}++describe('downloadFile checksum verification', () => {+ test('keeps the file when the bytes match the published sha256', async () => {+ const {downloadFile} = loadFileDownloads();+ const destPath = destination();++ await downloadFile(`${baseUrl}/payload`, destPath, {sha256: PAYLOAD_SHA256});++ assert.equal(readFileSync(destPath).equals(PAYLOAD), true);+ });++ test('accepts an uppercase published sha256', async () => {+ const {downloadFile} = loadFileDownloads();+ const destPath = destination();++ await downloadFile(`${baseUrl}/payload`, destPath, {sha256: PAYLOAD_SHA256.toUpperCase()});++ assert.equal(readFileSync(destPath).equals(PAYLOAD), true);+ });++ test('verifies the bytes that survive a redirect', async () => {+ const {downloadFile} = loadFileDownloads();+ const destPath = destination();++ await downloadFile(`${baseUrl}/redirect`, destPath, {sha256: PAYLOAD_SHA256});++ assert.equal(readFileSync(destPath).equals(PAYLOAD), true);+ });++ test('deletes the download and reports both digests when the bytes do not match', async () => {+ const {downloadFile} = loadFileDownloads();+ const destPath = destination();++ await assert.rejects(downloadFile(`${baseUrl}/corrupt`, destPath, {sha256: PAYLOAD_SHA256}), (error) => {+ assert.equal(error.name, 'DownloadChecksumError');+ assert.match(error.message, new RegExp(PAYLOAD_SHA256));+ assert.match(error.message, new RegExp(CORRUPT_SHA256));+ return true;+ });++ assert.equal(existsSync(destPath), false);+ });++ test('leaves nothing behind when an earlier file sits at the destination', async () => {+ const {downloadFile} = loadFileDownloads();+ const destPath = destination();+ writeFileSync(destPath, Buffer.from('an older download'), {mode: 0o755});++ await assert.rejects(downloadFile(`${baseUrl}/corrupt`, destPath, {sha256: PAYLOAD_SHA256}));++ assert.equal(existsSync(destPath), false);+ });++ test('refuses an empty body when a checksum was published', async () => {+ const {downloadFile} = loadFileDownloads();+ const destPath = destination();++ await assert.rejects(downloadFile(`${baseUrl}/empty`, destPath, {sha256: PAYLOAD_SHA256}), (error) => {+ assert.equal(error.name, 'DownloadChecksumError');+ assert.match(error.message, new RegExp(EMPTY_SHA256));+ return true;+ });++ assert.equal(existsSync(destPath), false);+ });++ test('refuses a malformed checksum before asking for any bytes', async () => {+ const {downloadFile} = loadFileDownloads();+ const destPath = destination();+ const requestsBefore = requests;++ await assert.rejects(downloadFile(`${baseUrl}/payload`, destPath, {sha256: 'deb-2026.909.202036'}), (error) => {+ assert.equal(error.message, 'Download checksum is malformed');+ return true;+ });++ assert.equal(requests, requestsBefore);+ assert.equal(existsSync(destPath), false);+ });++ test('downloads without verifying when the feed published no checksum', async () => {+ const {downloadFile} = loadFileDownloads();+ const destPath = destination();++ await downloadFile(`${baseUrl}/corrupt`, destPath, {sha256: null});++ assert.equal(readFileSync(destPath).equals(CORRUPT), true);+ });+});diff --git a/fluxer_desktop/src/main/FileDownloads.ts b/fluxer_desktop/src/main/FileDownloads.tsindex 6fe265fbb..b33a907f7 100644--- a/fluxer_desktop/src/main/FileDownloads.ts+++ b/fluxer_desktop/src/main/FileDownloads.ts@@ -1,5 +1,6 @@// SPDX-License-Identifier: AGPL-3.0-or-later+import {createHash, type Hash} from 'node:crypto';import fs from 'node:fs';import {pipeline} from 'node:stream/promises';import {@@ -13,9 +14,32 @@ const MAX_DOWNLOAD_REDIRECTS = 5;const DOWNLOAD_DEADLINE_MS = 600_000;const DOWNLOAD_MAX_BYTES = 512 * 1024 * 1024;const DOWNLOAD_CONTEXT = 'File download';+const SHA256_PATTERN = /^[0-9a-f]{64}$/;++export class DownloadChecksumError extends Error {+ constructor(expected: string, actual: string) {+ super(`Download checksum mismatch: expected ${expected}, downloaded ${actual}`);+ this.name = 'DownloadChecksumError';+ }+}interface DownloadFileOptions {maxBytes?: number;+ sha256?: string | null;+}++function parseExpectedSha256(value: string | null | undefined): string | null {+ if (value == null) {+ return null;+ }+ const expected = value.trim().toLowerCase();+ if (expected.length === 0) {+ return null;+ }+ if (!SHA256_PATTERN.test(expected)) {+ throw new Error('Download checksum is malformed');+ }+ return expected;}async function removePartialDownload(destPath: string): Promise<void> {@@ -26,13 +50,16 @@ async function writeCappedResponse(response: DesktopOutboundHTTPMessage['message'],destPath: string,maxBytes: number,+ hash: Hash | null,): Promise<void> {let received = 0;response.on('data', (chunk: Buffer) => {received += chunk.length;if (received > maxBytes) {response.destroy(new Error(`Download exceeds ${maxBytes} bytes`));+ return;}+ hash?.update(chunk);});await pipeline(response, fs.createWriteStream(destPath));}@@ -42,6 +69,7 @@ async function downloadFileWithRedirects(destPath: string,redirects: number,maxBytes: number,+ hash: Hash | null,): Promise<void> {const message = await getDesktopOutboundHTTP().get({context: DOWNLOAD_CONTEXT,@@ -58,7 +86,7 @@ async function downloadFileWithRedirects(if (nextUrl == null) {throw new Error(`HTTP ${statusCode} redirect target is unusable`);}- await downloadFileWithRedirects(nextUrl, destPath, redirects + 1, maxBytes);+ await downloadFileWithRedirects(nextUrl, destPath, redirects + 1, maxBytes, hash);return;}if (statusCode === 204 || statusCode === 205) {@@ -71,7 +99,7 @@ async function downloadFileWithRedirects(throw new Error(`HTTP ${statusCode}`);}try {- await writeCappedResponse(message.message, destPath, maxBytes);+ await writeCappedResponse(message.message, destPath, maxBytes, hash);} catch (error) {await removePartialDownload(destPath);throw error;@@ -83,7 +111,18 @@ export async function downloadFile(url: string, destPath: string, options: Downlif (target == null) {throw new Error('Download URL must use http or https');}+ const expectedSha256 = parseExpectedSha256(options.sha256);+ const hash = expectedSha256 === null ? null : createHash('sha256');const maxBytes = options.maxBytes ?? DOWNLOAD_MAX_BYTES;await removePartialDownload(destPath);- await downloadFileWithRedirects(target, destPath, 0, maxBytes);+ await downloadFileWithRedirects(target, destPath, 0, maxBytes, hash);+ if (expectedSha256 === null || hash === null) {+ return;+ }+ const digest = hash.digest('hex');+ if (digest === expectedSha256) {+ return;+ }+ await removePartialDownload(destPath);+ throw new DownloadChecksumError(expectedSha256, digest);}diff --git a/fluxer_desktop/src/main/IpcHandlers.ts b/fluxer_desktop/src/main/IpcHandlers.tsindex de345a84e..8d47a83ff 100644--- a/fluxer_desktop/src/main/IpcHandlers.ts+++ b/fluxer_desktop/src/main/IpcHandlers.ts@@ -20,7 +20,7 @@ import {hasActiveDesktopTray,updateTrayRuntimeState,} from '@electron/main/DesktopTray';-import {downloadFile} from '@electron/main/FileDownloads';+import {DownloadChecksumError, downloadFile} from '@electron/main/FileDownloads';import {type LinuxAppearanceSnapshot,type LinuxAppearanceSubscription,@@ -381,6 +381,7 @@ export function registerIpcHandlers(): void {options: {url: string;defaultPath: string;+ sha256?: string | null;},): Promise<DownloadFileResult> => {requirePrivilegedRendererDocumentSender(event, 'download-file');@@ -395,9 +396,12 @@ export function registerIpcHandlers(): void {if (result.canceled || !result.filePath) {return {success: false, canceled: true};}- await downloadFile(options.url, result.filePath);+ await downloadFile(options.url, result.filePath, {sha256: options.sha256});return {success: true, path: result.filePath};} catch (error) {+ if (error instanceof DownloadChecksumError) {+ return {success: false, checksumMismatch: true, error: error.message};+ }return {success: false, error: error instanceof Error ? error.message : 'Unknown error'};}},diff --git a/fluxer_desktop/src/main/LinuxLaunchPath.test.mjs b/fluxer_desktop/src/main/LinuxLaunchPath.test.mjsnew file mode 100644index 000000000..3cff45a76--- /dev/null+++ b/fluxer_desktop/src/main/LinuxLaunchPath.test.mjs@@ -0,0 +1,223 @@+// SPDX-License-Identifier: AGPL-3.0-or-later++import assert from 'node:assert/strict';+import {spawn, spawnSync} from 'node:child_process';+import {chmodSync, existsSync, mkdtempSync, readFileSync, writeFileSync} from 'node:fs';+import {createRequire} from 'node:module';+import {tmpdir} from 'node:os';+import {join} 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('./LinuxLaunchPath.ts', import.meta.url));+const transformedSource = esbuild.transformSync(readFileSync(sourcePath, 'utf8'), {+ loader: 'ts',+ format: 'cjs',+ platform: 'node',+ target: 'node20',+}).code;++const APPIMAGE_PATH = '/home/hampus/Applications/My Fluxer.AppImage';+const EXEC_PATH = '/tmp/.mount_My FluhKjNGD/fluxer-canary';++function loadLaunchPath({+ platform = 'linux',+ appImagePath = APPIMAGE_PATH,+ argv = [],+ spawnThrows = false,+ shells = ['/bin/bash'],+} = {}) {+ const spawned = [];+ const relaunched = [];+ const module = {exports: {}};+ const stubs = {+ '@electron/common/Logger': {createChildLogger: () => ({debug() {}, info() {}, warn() {}, error() {}})},+ electron: {+ app: {+ relaunch(options) {+ relaunched.push(options);+ },+ },+ },+ 'node:child_process': {+ spawn(command, args, options) {+ if (spawnThrows) {+ throw new Error('spawn EPERM');+ }+ let unrefCalls = 0;+ const child = {+ pid: 4242,+ unref() {+ unrefCalls += 1;+ },+ get unrefCalls() {+ return unrefCalls;+ },+ };+ spawned.push({command, args, options, child});+ return child;+ },+ },+ 'node:fs': {existsSync: (path) => shells.includes(path)},+ 'node:os': {homedir: () => '/home/hampus'},+ };+ const context = vm.createContext({+ module,+ exports: module.exports,+ console,+ process: {+ platform,+ pid: 13274,+ execPath: EXEC_PATH,+ argv: [EXEC_PATH, ...argv],+ env: appImagePath ? {APPIMAGE: appImagePath} : {},+ },+ require: (specifier) => stubs[specifier] ?? require(specifier),+ });+ vm.runInContext(transformedSource, context, {filename: sourcePath});+ return {...module.exports, spawned, relaunched};+}++describe('Linux launch path', () => {+ test('reports the AppImage as the stable launch path', () => {+ assert.equal(loadLaunchPath({}).getStableLinuxLaunchPath(), APPIMAGE_PATH);+ assert.equal(loadLaunchPath({appImagePath: null}).getStableLinuxLaunchPath(), EXEC_PATH);+ assert.equal(loadLaunchPath({platform: 'darwin'}).getStableLinuxLaunchPath(), EXEC_PATH);+ });+});++function relaunchScript() {+ const probe = loadLaunchPath({});+ probe.relaunchStableLaunchPath();+ return probe.spawned[0].args[1];+}++describe('AppImage relaunch script', () => {+ for (const shell of ['/bin/bash', '/bin/sh']) {+ test(`replaces the process once the parent exits under ${shell}`, {skip: !existsSync(shell)}, async () => {+ const root = mkdtempSync(join(tmpdir(), 'fluxer-relaunch-test-'));+ const marker = join(root, 'replacement-argv');+ const replacement = join(root, 'My Fluxer.AppImage');+ writeFileSync(replacement, `#!${shell}\nprintf '%s\\n' "$@" > '${marker}'\n`, {mode: 0o755});+ const parent = spawn(shell, ['-c', 'sleep 30'], {stdio: 'ignore', detached: true});+ parent.unref();++ const relaunch = spawn(+ shell,+ [+ '-c',+ relaunchScript(),+ 'fluxer-relaunch',+ String(parent.pid),+ replacement,+ root,+ '--fluxer-portable',+ 'fluxer://invite/a b',+ ],+ {cwd: root, detached: true, stdio: 'ignore'},+ );+ relaunch.unref();++ spawnSync('kill', [String(parent.pid)]);+ for (let attempt = 0; attempt < 100 && !existsSync(marker); attempt += 1) {+ await new Promise((resolve) => setTimeout(resolve, 100));+ }++ assert.equal(existsSync(marker), true, 'the replacement never started');+ assert.deepEqual(readFileSync(marker, 'utf8').split('\n').slice(0, 2), [+ '--fluxer-portable',+ 'fluxer://invite/a b',+ ]);+ chmodSync(replacement, 0o755);+ });+ }+});++describe('AppImage relaunch', () => {+ test('never asks Electron to relaunch an AppImage', () => {+ const updater = loadLaunchPath({argv: ['--fluxer-portable']});++ updater.relaunchStableLaunchPath();++ assert.equal(+ updater.relaunched.length,+ 0,+ "Electron's relauncher runs under PR_SET_NO_NEW_PRIVS, which makes the setuid fusermount the AppImage runtime needs fail with EPERM, so the app quits and never comes back",+ );+ assert.equal(updater.spawned.length, 1);+ const [relaunch] = updater.spawned;+ assert.equal(relaunch.command, '/bin/bash');+ assert.equal(relaunch.options.detached, true);+ assert.equal(relaunch.options.stdio, 'ignore');+ assert.equal(relaunch.options.cwd, '/home/hampus');+ assert.equal(relaunch.child.unrefCalls, 1);+ });++ test('waits for this process to exit before starting the replacement, and keeps its arguments', () => {+ const updater = loadLaunchPath({argv: ['--fluxer-portable', 'fluxer://invite/a b']});++ updater.relaunchStableLaunchPath();++ const [flag, script, name, pid, target, home, ...forwarded] = updater.spawned[0].args;+ assert.equal(flag, '-c');+ assert.match(script, /kill -0 "\$pid"/);+ assert.match(script, /exec "\$app" "\$@"/);+ assert.equal(name, 'fluxer-relaunch');+ assert.equal(pid, '13274');+ assert.equal(target, APPIMAGE_PATH);+ assert.equal(home, '/home/hampus');+ assert.deepEqual(forwarded, ['--fluxer-portable', 'fluxer://invite/a b']);+ });++ test('hands the replacement a clean descriptor table', () => {+ const updater = loadLaunchPath({});++ updater.relaunchStableLaunchPath();++ const script = updater.spawned[0].args[1];+ assert.match(+ script,+ /cd \/proc\/self\/fd/,+ "Chromium leaves its icudtl.dat, v8 snapshot, .pak and app.asar descriptors open across a spawn, so the replacement would pin the outgoing build's fuse mount and its unlinked AppImage for as long as it runs",+ );+ assert.match(+ script,+ /\[ -n "\$BASH_VERSION" \]/,+ 'dash only parses single digit descriptor numbers, and a failed exec kills a non-interactive shell, so the two-digit closes have to be guarded',+ );+ });++ test('falls back to the system shell when bash is missing', () => {+ const updater = loadLaunchPath({shells: ['/bin/sh']});++ updater.relaunchStableLaunchPath();++ assert.equal(updater.spawned[0].command, '/bin/sh');+ assert.equal(updater.relaunched.length, 0);+ });++ test('leaves every other install to Electron', () => {+ const deb = loadLaunchPath({appImagePath: null});+ deb.relaunchStableLaunchPath();+ assert.equal(deb.spawned.length, 0);+ assert.deepEqual(deb.relaunched, [undefined]);++ const mac = loadLaunchPath({platform: 'darwin'});+ mac.relaunchStableLaunchPath();+ assert.equal(mac.spawned.length, 0);+ assert.deepEqual(mac.relaunched, [undefined]);+ });++ test('falls back to Electron when the replacement process cannot be started', () => {+ const updater = loadLaunchPath({spawnThrows: true});++ updater.relaunchStableLaunchPath();++ assert.equal(updater.relaunched.length, 1);+ assert.equal(updater.relaunched[0]?.execPath, APPIMAGE_PATH);+ });+});diff --git a/fluxer_desktop/src/main/LinuxLaunchPath.ts b/fluxer_desktop/src/main/LinuxLaunchPath.tsindex 2fb8886f6..6c30a9e60 100644--- a/fluxer_desktop/src/main/LinuxLaunchPath.ts+++ b/fluxer_desktop/src/main/LinuxLaunchPath.ts@@ -1,16 +1,57 @@// SPDX-License-Identifier: AGPL-3.0-or-later+import {spawn} from 'node:child_process';+import {existsSync} from 'node:fs';+import {homedir} from 'node:os';+import {createChildLogger} from '@electron/common/Logger';+import {app} from 'electron';++const logger = createChildLogger('LinuxLaunchPath');++const PREFERRED_RELAUNCH_SHELL = '/bin/bash';+const FALLBACK_RELAUNCH_SHELL = '/bin/sh';++const RELAUNCH_AFTER_EXIT =+ 'pid="$1"; app="$2"; home="$3"; shift 3; cd /proc/self/fd && for n in *; do case "$n" in 0|1|2) ;; [0-9]) eval "exec $n>&-";; *) [ -n "$BASH_VERSION" ] && eval "exec $n>&-";; esac; done; cd "$home" || cd /; attempt=0; while [ "$attempt" -lt 300 ] && kill -0 "$pid"; do sleep 0.1; attempt=$((attempt + 1)); done; kill -0 "$pid" || exec "$app" "$@"';++function getAppImagePath(): string | null {+ if (process.platform !== 'linux') return null;+ const appImage = process.env.APPIMAGE;+ return appImage && appImage.length > 0 ? appImage : null;+}+export function getStableLinuxLaunchPath(): string {- if (process.platform === 'linux') {- const appImage = process.env.APPIMAGE;- if (appImage && appImage.length > 0) return appImage;- }- return process.execPath;+ return getAppImagePath() ?? process.execPath;}-export function getStableRelaunchOptions(): {execPath: string} | undefined {- if (process.platform !== 'linux') return undefined;- const execPath = getStableLinuxLaunchPath();- if (execPath === process.execPath) return undefined;- return {execPath};+export function relaunchStableLaunchPath(): void {+ const appImagePath = getAppImagePath();+ if (appImagePath == null) {+ app.relaunch();+ return;+ }+ try {+ const child = spawn(+ existsSync(PREFERRED_RELAUNCH_SHELL) ? PREFERRED_RELAUNCH_SHELL : FALLBACK_RELAUNCH_SHELL,+ [+ '-c',+ RELAUNCH_AFTER_EXIT,+ 'fluxer-relaunch',+ String(process.pid),+ appImagePath,+ homedir(),+ ...process.argv.slice(1),+ ],+ {+ cwd: homedir(),+ detached: true,+ stdio: 'ignore',+ },+ );+ child.unref();+ logger.info('Relaunching the AppImage once this process exits', {path: appImagePath, pid: child.pid});+ } catch (error) {+ logger.error('Failed to start the AppImage replacement process', {error});+ app.relaunch({execPath: appImagePath});+ }}diff --git a/fluxer_desktop/src/main/Troubleshooting.ts b/fluxer_desktop/src/main/Troubleshooting.tsindex 41a9f57e2..3ba47b264 100644--- a/fluxer_desktop/src/main/Troubleshooting.ts+++ b/fluxer_desktop/src/main/Troubleshooting.ts@@ -4,7 +4,7 @@ import {setDesktopTroubleshootingSettings} from '@electron/common/DesktopConfig'import {createChildLogger} from '@electron/common/Logger';import {getLaunchDesktopTroubleshootingSettings} from '@electron/main/DesktopDebugInfo';import {destroyDesktopTray} from '@electron/main/DesktopTray';-import {getStableRelaunchOptions} from '@electron/main/LinuxLaunchPath';+import {relaunchStableLaunchPath} from '@electron/main/LinuxLaunchPath';import {t} from '@electron/main/MainI18n';import {clearSavedWindowBounds, getMainWindow, setQuitting} from '@electron/main/Window';import {app, BrowserWindow, dialog, Menu, type MenuItemConstructorOptions, session} from 'electron';@@ -21,7 +21,7 @@ export function relaunchAndExit(): void {relaunchRequested = true;setQuitting(true);destroyDesktopTray();- app.relaunch(getStableRelaunchOptions());+ relaunchStableLaunchPath();app.exit(0);}diff --git a/fluxer_desktop/src/main/Updater.test.mjs b/fluxer_desktop/src/main/Updater.test.mjsnew file mode 100644index 000000000..dbb9097f5--- /dev/null+++ b/fluxer_desktop/src/main/Updater.test.mjs@@ -0,0 +1,448 @@+// SPDX-License-Identifier: AGPL-3.0-or-later++import assert from 'node:assert/strict';+import {createHash} from 'node:crypto';+import {chmodSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, writeFileSync} from 'node:fs';+import {createServer} from 'node:http';+import {createRequire} from 'node:module';+import {tmpdir} from 'node:os';+import {join} from 'node:path';+import {after, before, 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');++function transform(name) {+ const url = new URL(`./${name}`, import.meta.url);+ const path = fileURLToPath(url);+ return {+ path,+ code: esbuild.transformSync(readFileSync(path, 'utf8'), {+ loader: 'ts',+ format: 'cjs',+ platform: 'node',+ target: 'node20',+ define: {'import.meta.url': JSON.stringify(url.href)},+ }).code,+ };+}++const appImageUpdateSource = transform('AppImageUpdate.ts');+const updaterDownloadsSource = transform('UpdaterDownloads.ts');+const updaterSource = transform('Updater.ts');+const updaterPlatformUtilsSource = transform('../../../fluxer_app/src/features/app/utils/UpdaterPlatformUtils.ts');++function loadUpdaterPlatformUtils() {+ const module = {exports: {}};+ const context = vm.createContext({module, exports: module.exports, require});+ vm.runInContext(updaterPlatformUtilsSource.code, context, {filename: updaterPlatformUtilsSource.path});+ return module.exports;+}++const INSTALLED_NAME = 'My Fluxer.AppImage';+const CURRENT_VERSION = '2026.903.231208';+const PUBLISHED_VERSION = '2026.904.135113';+const OLD_BYTES = Buffer.from('installed-appimage');+const NEW_BYTES = Buffer.alloc(300_000, 3);+const NEW_SHA256 = createHash('sha256').update(NEW_BYTES).digest('hex');++let server;+let baseUrl;+let serveCorruptBytes = false;+let appImageRequests = 0;+let failAppImageRequests = 0;++before(async () => {+ server = createServer((request, response) => {+ if (request.url === '/latest') {+ response.writeHead(200, {'content-type': 'application/json'});+ response.end(+ JSON.stringify({+ version: PUBLISHED_VERSION,+ pub_date: '2026-09-04T13:51:13Z',+ files: {+ appimage: {url: `${baseUrl}/appimage`, sha256: NEW_SHA256},+ deb: {url: `${baseUrl}/deb`, sha256: 'deadbeef'},+ },+ }),+ );+ return;+ }+ if (request.url === `/${PUBLISHED_VERSION}/appimage`) {+ appImageRequests += 1;+ if (failAppImageRequests > 0) {+ failAppImageRequests -= 1;+ response.writeHead(503);+ response.end('try again');+ return;+ }+ const body = serveCorruptBytes ? Buffer.concat([Buffer.from([0]), NEW_BYTES.subarray(1)]) : NEW_BYTES;+ response.writeHead(200, {'content-type': 'application/octet-stream', 'content-length': body.length});+ response.end(body);+ return;+ }+ response.writeHead(404);+ response.end('missing');+ });+ await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));+ baseUrl = `http://127.0.0.1:${server.address().port}`;+});++after(async () => {+ await new Promise((resolve) => server.close(resolve));+});++function createInstall() {+ const root = mkdtempSync(join(tmpdir(), 'fluxer-updater-test-'));+ const applications = join(root, 'Applications');+ mkdirSync(applications);+ const mount = join(root, '.mount_Fluxer');+ mkdirSync(mount);+ writeFileSync(join(mount, 'AppRun'), '#!/usr/bin/env bash\n', {mode: 0o755});+ const installedPath = join(applications, INSTALLED_NAME);+ writeFileSync(installedPath, OLD_BYTES, {mode: 0o755});+ return {applications, installedPath, mount};+}++function loadUpdater({appImagePath, version = CURRENT_VERSION, appDir, execPath, stagingErrno}) {+ const events = [];+ const handlers = new Map();+ const appEvents = new Map();+ const state = {relaunched: false, electronRelaunched: false};+ const module = {exports: {}};+ const stubs = {+ '@electron/common/BuildChannel': {BUILD_CHANNEL: 'canary'},+ '@electron/common/UserDataPath': {isPortableMode: () => false},+ '@electron/main/DesktopTray': {destroyDesktopTray() {}},+ '@electron/main/LinuxSandbox': {isFlatpakRuntime: () => false},+ '@electron/main/Troubleshooting': {+ relaunchAndExit() {+ state.relaunched = true;+ },+ },+ '@electron/main/Window': {setQuitting() {}},+ 'electron-log': {info() {}, warn() {}, error() {}, debug() {}},+ electron: {+ app: {+ isPackaged: true,+ getVersion: () => version,+ on(event, handler) {+ appEvents.set(event, handler);+ },+ relaunch() {+ state.electronRelaunched = true;+ },+ exit() {},+ },+ autoUpdater: {on() {}},+ ipcMain: {+ handle(channel, handler) {+ handlers.set(channel, handler);+ },+ },+ },+ };+ const sandbox = {+ console,+ Buffer,+ process: {+ ...process,+ platform: 'linux',+ arch: 'arm64',+ execPath: execPath ?? (appDir ? join(appDir, 'fluxer-canary') : process.execPath),+ env: {+ ...(appImagePath ? {APPIMAGE: appImagePath} : {}),+ ...(appDir ? {APPDIR: appDir} : {}),+ },+ },+ setTimeout,+ clearTimeout,+ fetch: (input, init) => {+ const url = String(input).replace('https://pkgs.fluxer.com/desktop/canary/linux/arm64', baseUrl);+ return fetch(url, init);+ },+ require: (specifier) => {+ if (specifier === 'node:fs/promises' && stagingErrno) {+ return {+ ...require(specifier),+ open: async () => {+ const error = new Error(`${stagingErrno}: staging refused`);+ error.code = stagingErrno;+ throw error;+ },+ };+ }+ return stubs[specifier] ?? require(specifier);+ },+ };+ const context = vm.createContext(sandbox);++ const appImageModule = {exports: {}};+ sandbox.module = appImageModule;+ sandbox.exports = appImageModule.exports;+ sandbox.__filename = appImageUpdateSource.path;+ vm.runInContext(appImageUpdateSource.code, context, {filename: appImageUpdateSource.path});+ stubs['@electron/main/AppImageUpdate'] = appImageModule.exports;++ const updaterDownloadsModule = {exports: {}};+ sandbox.module = updaterDownloadsModule;+ sandbox.exports = updaterDownloadsModule.exports;+ sandbox.__filename = updaterDownloadsSource.path;+ vm.runInContext(updaterDownloadsSource.code, context, {filename: updaterDownloadsSource.path});+ stubs['@electron/main/UpdaterDownloads'] = updaterDownloadsModule.exports;++ sandbox.module = module;+ sandbox.exports = module.exports;+ sandbox.__filename = updaterSource.path;+ vm.runInContext(updaterSource.code, context, {filename: updaterSource.path});++ module.exports.registerUpdater(() => ({webContents: {send: (_channel, event) => events.push(event)}}));+ return {+ events,+ state,+ check: () => handlers.get('updater-check')({}, 'user'),+ install: () => handlers.get('updater-install')({}),+ quit: () => appEvents.get('will-quit')?.(),+ };+}++function types(events) {+ return events.map((event) => event.type);+}++function stagingLeftovers(directory) {+ return readdirSync(directory).filter((entry) => entry.startsWith('.fluxer-update-'));+}++describe('Updater AppImage lifecycle', () => {+ test('downloads on check, reports the macOS lifecycle, and swaps in place', async () => {+ const install = createInstall();+ const updater = loadUpdater({appImagePath: install.installedPath, appDir: install.mount});++ await updater.check();++ const available = updater.events.find((event) => event.type === 'available');+ assert.equal(available.downloadStarted, true);+ assert.equal(available.version, PUBLISHED_VERSION);+ assert.equal(available.downloadUrl, undefined);+ assert.equal(available.downloadOptions, undefined);+ const progress = updater.events.filter((event) => event.type === 'progress');+ assert.ok(progress.length > 0);+ assert.equal(progress.at(-1).total, NEW_BYTES.length);+ assert.equal(progress.at(-1).transferred, NEW_BYTES.length);+ assert.equal(progress.at(-1).percent, 100);+ const downloaded = updater.events.find((event) => event.type === 'downloaded');+ assert.equal(downloaded.version, PUBLISHED_VERSION);+ assert.deepEqual(+ types(updater.events).filter((type) => type !== 'progress'),+ ['checking', 'available', 'downloaded'],+ );+ assert.equal(readFileSync(install.installedPath).equals(OLD_BYTES), true);++ await updater.install();++ assert.equal(updater.state.relaunched, true);+ assert.equal(+ updater.state.electronRelaunched,+ false,+ "app.relaunch cannot start an AppImage: Electron's relauncher runs under PR_SET_NO_NEW_PRIVS and the setuid fusermount the AppImage runtime needs fails with EPERM",+ );+ assert.deepEqual(readdirSync(install.applications), [INSTALLED_NAME]);+ assert.equal(readFileSync(install.installedPath).equals(NEW_BYTES), true);+ });++ test('refuses to swap when the download does not match the published sha256', async () => {+ const install = createInstall();+ const updater = loadUpdater({appImagePath: install.installedPath, appDir: install.mount});+ serveCorruptBytes = true;+ try {+ await updater.check();+ } finally {+ serveCorruptBytes = false;+ }++ assert.deepEqual(+ types(updater.events).filter((type) => type !== 'progress'),+ ['checking', 'available', 'error', 'available'],+ );+ const failure = updater.events.find((event) => event.type === 'error');+ assert.equal(failure.phase, 'download');+ assert.match(failure.message, /checksum mismatch/);+ const fallback = updater.events.at(-1);+ assert.equal(fallback.downloadStarted, false);+ assert.ok(fallback.downloadOptions.length > 0);+ assert.equal(readFileSync(install.installedPath).equals(OLD_BYTES), true);+ assert.deepEqual(stagingLeftovers(install.applications), []);+ await assert.rejects(updater.install(), /No AppImage update is ready to install/);+ });++ test('offers the manual download when the install directory is not writable', {+ skip: process.getuid?.() === 0,+ }, async () => {+ const install = createInstall();+ chmodSync(install.applications, 0o500);+ try {+ const updater = loadUpdater({appImagePath: install.installedPath, appDir: install.mount});++ await updater.check();++ assert.deepEqual(types(updater.events), ['checking', 'available']);+ const available = updater.events.at(-1);+ assert.equal(available.downloadStarted, false);+ assert.equal(available.version, PUBLISHED_VERSION);+ assert.ok(available.downloadOptions.length > 0);+ assert.equal(available.downloadOptions[0].format, 'appimage');+ assert.equal(+ available.downloadOptions[0].suggestedName,+ `Fluxer-Canary-${PUBLISHED_VERSION}-linux-arm64.AppImage`,+ );+ } finally {+ chmodSync(install.applications, 0o755);+ }+ assert.equal(readFileSync(install.installedPath).equals(OLD_BYTES), true);+ assert.deepEqual(readdirSync(install.applications), [INSTALLED_NAME]);+ });++ test('falls back to the manual updater when APPIMAGE is unset', async () => {+ const updater = loadUpdater({appImagePath: null});++ await updater.check();++ assert.deepEqual(types(updater.events), ['checking', 'available']);+ assert.equal(updater.events.at(-1).downloadStarted, false);+ await assert.rejects(updater.install(), /In-app updates are not supported on this platform/);+ });++ test('never rewrites an inherited APPIMAGE that this process did not come from', async () => {+ const install = createInstall();+ const victim = join(install.applications, 'Kdenlive-24.12.AppImage');+ writeFileSync(victim, OLD_BYTES, {mode: 0o755});+ const optDir = mkdtempSync(join(tmpdir(), 'fluxer-opt-test-'));+ const updater = loadUpdater({appImagePath: victim, execPath: join(optDir, 'fluxer')});++ await updater.check();++ assert.deepEqual(types(updater.events), ['checking', 'available']);+ assert.equal(updater.events.at(-1).downloadStarted, false);+ assert.equal(readFileSync(victim).equals(OLD_BYTES), true);+ assert.deepEqual(stagingLeftovers(install.applications), []);+ await assert.rejects(updater.install(), /In-app updates are not supported on this platform/);+ });++ test('never rewrites the AppImage that only the shell around this process came from', async () => {+ const install = createInstall();+ const victim = join(install.applications, 'Kdenlive-24.12.AppImage');+ writeFileSync(victim, OLD_BYTES, {mode: 0o755});+ const extracted = join(mkdtempSync(join(tmpdir(), 'fluxer-extracted-test-')), 'squashfs-root');+ mkdirSync(extracted);+ writeFileSync(join(extracted, 'AppRun'), '#!/usr/bin/env bash\n', {mode: 0o755});+ const updater = loadUpdater({+ appImagePath: victim,+ appDir: install.mount,+ execPath: join(extracted, 'fluxer-canary'),+ });++ await updater.check();++ assert.deepEqual(types(updater.events), ['checking', 'available']);+ assert.equal(updater.events.at(-1).downloadStarted, false);+ assert.equal(readFileSync(victim).equals(OLD_BYTES), true);+ assert.deepEqual(stagingLeftovers(install.applications), []);+ await assert.rejects(updater.install(), /In-app updates are not supported on this platform/);+ });++ test('gives up on a local write failure instead of downloading the AppImage again', async () => {+ const install = createInstall();+ const updater = loadUpdater({+ appImagePath: install.installedPath,+ appDir: install.mount,+ stagingErrno: 'ENOSPC',+ });+ const before = appImageRequests;++ await updater.check();++ assert.equal(appImageRequests - before, 1, 'a full disk must not pull the whole AppImage down five more times');+ const failure = updater.events.find((event) => event.type === 'error');+ assert.equal(failure.phase, 'download');+ assert.match(failure.message, /ENOSPC/);+ assert.equal(updater.events.at(-1).type, 'available');+ assert.equal(updater.events.at(-1).downloadStarted, false);+ assert.deepEqual(readdirSync(install.applications), [INSTALLED_NAME]);+ });++ test('downloads the AppImage again after a transient server failure', async () => {+ const install = createInstall();+ const updater = loadUpdater({appImagePath: install.installedPath, appDir: install.mount});+ const before = appImageRequests;+ failAppImageRequests = 1;++ try {+ await updater.check();+ } finally {+ failAppImageRequests = 0;+ }++ assert.equal(appImageRequests - before, 2);+ assert.equal(updater.events.at(-1).type, 'downloaded');++ await updater.install();++ assert.equal(readFileSync(install.installedPath).equals(NEW_BYTES), true);+ });++ test('reports no update when the published version is not newer', async () => {+ const install = createInstall();+ const updater = loadUpdater({+ appImagePath: install.installedPath,+ appDir: install.mount,+ version: PUBLISHED_VERSION,+ });++ await updater.check();++ assert.deepEqual(types(updater.events), ['checking', 'not-available']);+ assert.deepEqual(readdirSync(install.applications), [INSTALLED_NAME]);+ });++ test('reclaims a staged update abandoned by a process that never reached will-quit', async () => {+ const install = createInstall();+ const abandoned = loadUpdater({appImagePath: install.installedPath, appDir: install.mount});++ await abandoned.check();+ assert.equal(stagingLeftovers(install.applications).length, 1);++ loadUpdater({appImagePath: install.installedPath, appDir: install.mount});++ assert.deepEqual(stagingLeftovers(install.applications), []);+ assert.deepEqual(readdirSync(install.applications), [INSTALLED_NAME]);+ assert.equal(readFileSync(install.installedPath).equals(OLD_BYTES), true);+ });++ test('shows the renderer the download progress the main process reports', async () => {+ const install = createInstall();+ const updater = loadUpdater({appImagePath: install.installedPath, appDir: install.mount});+ const {shouldShowNativeDesktopUpdateDownloadProgress} = loadUpdaterPlatformUtils();++ await updater.check();++ const reportsProgress = updater.events.some((event) => event.type === 'progress');+ assert.equal(reportsProgress, true);+ assert.equal(shouldShowNativeDesktopUpdateDownloadProgress('linux'), reportsProgress);+ });++ test('discards a staged update that the user never installed', async () => {+ const install = createInstall();+ const updater = loadUpdater({appImagePath: install.installedPath, appDir: install.mount});++ await updater.check();+ assert.equal(stagingLeftovers(install.applications).length, 1);++ updater.quit();++ assert.deepEqual(stagingLeftovers(install.applications), []);+ assert.equal(readFileSync(install.installedPath).equals(OLD_BYTES), true);+ });+});diff --git a/fluxer_desktop/src/main/Updater.ts b/fluxer_desktop/src/main/Updater.tsindex a9ec7f8d5..d52c209d5 100644--- a/fluxer_desktop/src/main/Updater.ts+++ b/fluxer_desktop/src/main/Updater.ts@@ -2,9 +2,23 @@import {createRequire} from 'node:module';import {isPortableMode} from '@electron/common/UserDataPath';+import {+ AppImageChecksumError,+ AppImageStagingError,+ type AppImageTarget,+ applyStagedAppImageUpdate,+ discardStagedAppImageUpdate,+ isRunningFromAppImage,+ resolveAppImageTarget,+ type StagedAppImageUpdate,+ stageAppImageUpdate,+ sweepAbandonedAppImageUpdates,+} from '@electron/main/AppImageUpdate';import {destroyDesktopTray} from '@electron/main/DesktopTray';import {isFlatpakRuntime} from '@electron/main/LinuxSandbox';+import {relaunchAndExit} from '@electron/main/Troubleshooting';import {+ buildManualVersionDownloadUrl,DOWNLOAD_PAGE_URL,getManualDownloadOptions,getManualDownloadUrl,@@ -74,11 +88,17 @@ let pendingVelopackUpdate: VelopackUpdate | null = null;let velopackCheckPromise: Promise<void> | null = null;let velopackDownloadPromise: Promise<void> | null = null;let velopackInstallStarted = false;+let pendingAppImageUpdate: PendingAppImageUpdate | null = null;+let appImageUpdatePromise: Promise<void> | null = null;+let appImageInstallStarted = false;const UPDATE_DOWNLOAD_MAX_ATTEMPTS = 5;const UPDATE_DOWNLOAD_RETRY_BASE_DELAY_MS = 3000;const UPDATE_DOWNLOAD_RETRY_MAX_DELAY_MS = 60000;const ELECTRON_DOWNLOAD_MAX_RETRIES = 4;+const UPDATE_PROGRESS_SAMPLE_INTERVAL_MS = 500;++type PendingAppImageUpdate = {version: string; target: AppImageTarget; staged: StagedAppImageUpdate};function send(win: BrowserWindow | null, event: UpdaterEvent) {win?.webContents.send('updater-event', event);@@ -472,22 +492,30 @@ async function fetchManualLatest(options: {forceRefresh?: boolean} = {}): Promisreturn info;}+function sendManualUpdateAvailable(+ getMainWindow: () => BrowserWindow | null,+ context: UpdaterContext,+ latest: ManualLatestInfo,+): void {+ const downloadOptions = getManualDownloadOptions(latest);+ send(getMainWindow(), {+ type: 'available',+ context,+ version: latest.version,+ downloadSize: null,+ downloadStarted: false,+ downloadUrl: getManualDownloadUrl(latest),+ ...(downloadOptions.length > 0 ? {downloadOptions} : {}),+ });+}+async function checkManualUpdate(context: UpdaterContext, getMainWindow: () => BrowserWindow | null): Promise<void> {send(getMainWindow(), {type: 'checking', context});try {const latest = await fetchManualLatest({forceRefresh: context === 'user'});const current = app.getVersion();if (compareVersions(latest.version, current) > 0) {- const downloadOptions = getManualDownloadOptions(latest);- send(getMainWindow(), {- type: 'available',- context,- version: latest.version,- downloadSize: null,- downloadStarted: false,- downloadUrl: getManualDownloadUrl(latest),- ...(downloadOptions.length > 0 ? {downloadOptions} : {}),- });+ sendManualUpdateAvailable(getMainWindow, context, latest);} else {send(getMainWindow(), {type: 'not-available', context});}@@ -497,6 +525,183 @@ async function checkManualUpdate(context: UpdaterContext, getMainWindow: () => B}}+async function downloadAppImageUpdate(+ context: UpdaterContext,+ getMainWindow: () => BrowserWindow | null,+ latest: ManualLatestInfo,+ target: AppImageTarget,+ expectedSha256: string,+): Promise<void> {+ const version = latest.version;+ const url = buildManualVersionDownloadUrl(version, 'appimage');+ let lastError: unknown;+ for (let attempt = 1; attempt <= UPDATE_DOWNLOAD_MAX_ATTEMPTS; attempt += 1) {+ let lastSampleAt = Date.now();+ let lastSampleTransferred = 0;+ let smoothedBytesPerSecond = 0;+ try {+ const staged = await stageAppImageUpdate({+ target,+ url,+ expectedSha256,+ onProgress: ({transferred, total}) => {+ const now = Date.now();+ const dtMs = now - lastSampleAt;+ const complete = total > 0 && transferred >= total;+ if (dtMs < UPDATE_PROGRESS_SAMPLE_INTERVAL_MS && !complete) {+ return;+ }+ if (dtMs > 0 && transferred >= lastSampleTransferred) {+ const instant = ((transferred - lastSampleTransferred) * 1000) / dtMs;+ smoothedBytesPerSecond =+ smoothedBytesPerSecond === 0 ? instant : smoothedBytesPerSecond * 0.7 + instant * 0.3;+ }+ lastSampleAt = now;+ lastSampleTransferred = transferred;+ send(getMainWindow(), {+ type: 'progress',+ context,+ percent: total > 0 ? Math.min(100, (transferred / total) * 100) : 0,+ transferred,+ total,+ bytesPerSecond: Math.round(smoothedBytesPerSecond),+ });+ },+ });+ if (pendingAppImageUpdate) {+ discardStagedAppImageUpdate(pendingAppImageUpdate.staged);+ }+ pendingAppImageUpdate = {version, target, staged};+ send(getMainWindow(), {type: 'downloaded', context, version});+ return;+ } catch (error) {+ lastError = error;+ if (+ error instanceof AppImageChecksumError ||+ error instanceof AppImageStagingError ||+ attempt >= UPDATE_DOWNLOAD_MAX_ATTEMPTS+ ) {+ break;+ }+ const delay = backoffDelay(attempt);+ const reason = getErrorMessage(error);+ const waitSeconds = Math.round(delay / 1000);+ log.warn(+ `AppImage update download attempt ${attempt}/${UPDATE_DOWNLOAD_MAX_ATTEMPTS} failed (${reason}), retrying in ${waitSeconds}s`,+ );+ await sleep(delay);+ }+ }+ log.error('AppImage update download failed', lastError);+ send(getMainWindow(), {type: 'error', context, phase: 'download', message: getErrorMessage(lastError)});+ sendManualUpdateAvailable(getMainWindow, context, latest);+}++async function checkAppImageUpdate(+ context: UpdaterContext,+ getMainWindow: () => BrowserWindow | null,+ target: AppImageTarget,+): Promise<void> {+ if (appImageUpdatePromise) {+ return appImageUpdatePromise;+ }+ appImageUpdatePromise = (async () => {+ send(getMainWindow(), {type: 'checking', context});+ let latest: ManualLatestInfo;+ try {+ latest = await fetchManualLatest({forceRefresh: context === 'user'});+ } catch (error) {+ log.warn('AppImage update check failed', error);+ send(getMainWindow(), {type: 'error', context, phase: 'check', message: getErrorMessage(error)});+ return;+ }+ if (pendingAppImageUpdate && compareVersions(latest.version, pendingAppImageUpdate.version) <= 0) {+ send(getMainWindow(), {type: 'downloaded', context, version: pendingAppImageUpdate.version});+ return;+ }+ if (compareVersions(latest.version, app.getVersion()) <= 0) {+ send(getMainWindow(), {type: 'not-available', context});+ return;+ }+ const published = latest.files.appimage;+ const resolved = resolveAppImageTarget(target.installedPath);+ if (!resolved.ok || !published?.sha256) {+ log.info('AppImage cannot be replaced in place, so the manual download is offered instead.', {+ reason: resolved.ok ? 'published-checksum-missing' : resolved.reason,+ });+ sendManualUpdateAvailable(getMainWindow, context, latest);+ return;+ }+ send(getMainWindow(), {+ type: 'available',+ context,+ version: latest.version,+ downloadSize: null,+ downloadStarted: true,+ });+ await downloadAppImageUpdate(context, getMainWindow, latest, resolved.target, published.sha256);+ })().finally(() => {+ appImageUpdatePromise = null;+ });+ return appImageUpdatePromise;+}++function installAppImageUpdate(getMainWindow: () => BrowserWindow | null): void {+ if (appImageInstallStarted) {+ log.warn('AppImage install already in progress, ignoring the duplicate request.');+ return;+ }+ const pending = pendingAppImageUpdate;+ if (!pending) {+ throw new Error('No AppImage update is ready to install.');+ }+ try {+ applyStagedAppImageUpdate(pending.target, pending.staged);+ } catch (error) {+ log.error('AppImage update install failed', error);+ pendingAppImageUpdate = null;+ send(getMainWindow(), {type: 'error', context: lastContext, phase: 'install', message: getErrorMessage(error)});+ return;+ }+ appImageInstallStarted = true;+ pendingAppImageUpdate = null;+ log.info(`Replaced ${pending.target.installedPath} with ${pending.version}, relaunching now.`);+ relaunchAndExit();+}++function reclaimAbandonedAppImageUpdates(target: AppImageTarget): void {+ try {+ const reclaimed = sweepAbandonedAppImageUpdates(target);+ if (reclaimed.length > 0) {+ log.info(`Reclaimed ${reclaimed.length} abandoned AppImage staging directories in ${target.directory}.`);+ }+ } catch (error) {+ log.warn('Failed to reclaim abandoned AppImage staging directories', error);+ }+}++function registerAppImageUpdater(getMainWindow: () => BrowserWindow | null, target: AppImageTarget): void {+ reclaimAbandonedAppImageUpdates(target);+ app.on('will-quit', () => {+ if (!pendingAppImageUpdate || appImageInstallStarted) {+ return;+ }+ discardStagedAppImageUpdate(pendingAppImageUpdate.staged);+ pendingAppImageUpdate = null;+ });+ ipcMain.handle('updater-check', async (_e, context: UpdaterContext) => {+ lastContext = context;+ await checkAppImageUpdate(context, getMainWindow, target);+ });+ ipcMain.handle('updater-download', async (_e, context: UpdaterContext) => {+ lastContext = context;+ await checkAppImageUpdate(context, getMainWindow, target);+ });+ ipcMain.handle('updater-install', async () => {+ installAppImageUpdate(getMainWindow);+ });+}+function registerManualUpdater(getMainWindow: () => BrowserWindow | null,reason: 'platform' | 'unpackaged' | 'managed-package',@@ -547,5 +752,12 @@ export function registerUpdater(getMainWindow: () => BrowserWindow | null) {registerElectronUpdater(getMainWindow);return;}+ if (process.platform === 'linux' && isRunningFromAppImage()) {+ const appImage = resolveAppImageTarget();+ if (appImage.ok) {+ registerAppImageUpdater(getMainWindow, appImage.target);+ return;+ }+ }registerManualUpdater(getMainWindow, 'platform');}diff --git a/fluxer_desktop/src/main/UpdaterDownloads.test.mjs b/fluxer_desktop/src/main/UpdaterDownloads.test.mjsindex 20e41a3f4..523812823 100644--- a/fluxer_desktop/src/main/UpdaterDownloads.test.mjs+++ b/fluxer_desktop/src/main/UpdaterDownloads.test.mjs@@ -63,28 +63,28 @@ describe('UpdaterDownloads Linux manual update options', () => {{format: 'appimage',label: 'AppImage',- url: 'https://api.fluxer.app/dl/desktop/stable/linux/x64/2026.910.101500/appimage',+ url: 'https://pkgs.fluxer.com/desktop/stable/linux/x64/2026.910.101500/appimage',suggestedName: 'Fluxer-2026.910.101500-linux-x86_64.AppImage',sha256: APPIMAGE_SHA256,},{format: 'deb',label: 'DEB package',- url: 'https://api.fluxer.app/dl/desktop/stable/linux/x64/2026.910.101500/deb',+ url: 'https://pkgs.fluxer.com/desktop/stable/linux/x64/2026.910.101500/deb',suggestedName: 'Fluxer-2026.910.101500-linux-amd64.deb',sha256: DEB_SHA256,},{format: 'rpm',label: 'RPM package',- url: 'https://api.fluxer.app/dl/desktop/stable/linux/x64/2026.910.101500/rpm',+ url: 'https://pkgs.fluxer.com/desktop/stable/linux/x64/2026.910.101500/rpm',suggestedName: 'Fluxer-2026.910.101500-linux-x86_64.rpm',sha256: null,},{format: 'tar_gz',label: 'tar.gz archive',- url: 'https://api.fluxer.app/dl/desktop/stable/linux/x64/2026.910.101500/tar_gz',+ url: 'https://pkgs.fluxer.com/desktop/stable/linux/x64/2026.910.101500/tar_gz',suggestedName: 'Fluxer-2026.910.101500-linux-x64.tar.gz',sha256: TAR_GZ_SHA256,},@@ -99,26 +99,26 @@ describe('UpdaterDownloads Linux manual update options', () => {options.map((option) => [option.url, option.suggestedName]),[[- 'https://api.fluxer.app/dl/desktop/stable/linux/arm64/2026.910.101500/appimage',+ 'https://pkgs.fluxer.com/desktop/stable/linux/arm64/2026.910.101500/appimage','Fluxer-2026.910.101500-linux-arm64.AppImage',],[- 'https://api.fluxer.app/dl/desktop/stable/linux/arm64/2026.910.101500/deb',+ 'https://pkgs.fluxer.com/desktop/stable/linux/arm64/2026.910.101500/deb','Fluxer-2026.910.101500-linux-arm64.deb',],[- 'https://api.fluxer.app/dl/desktop/stable/linux/arm64/2026.910.101500/rpm',+ 'https://pkgs.fluxer.com/desktop/stable/linux/arm64/2026.910.101500/rpm','Fluxer-2026.910.101500-linux-aarch64.rpm',],[- 'https://api.fluxer.app/dl/desktop/stable/linux/arm64/2026.910.101500/tar_gz',+ 'https://pkgs.fluxer.com/desktop/stable/linux/arm64/2026.910.101500/tar_gz','Fluxer-2026.910.101500-linux-arm64.tar.gz',],],);});- test('names canary and stable artefacts after their own product and api', () => {+ test('names canary and stable artefacts after their own product and origin', () => {const info = latestInfo('2026.910.101500');const stableDeb = structuredClone(loadUpdaterDownloads({channel: 'stable'}).getManualDownloadOptions(info)).find((option) => option.format === 'deb',@@ -127,9 +127,9 @@ describe('UpdaterDownloads Linux manual update options', () => {(option) => option.format === 'deb',);- assert.equal(stableDeb.url, 'https://api.fluxer.app/dl/desktop/stable/linux/x64/2026.910.101500/deb');+ assert.equal(stableDeb.url, 'https://pkgs.fluxer.com/desktop/stable/linux/x64/2026.910.101500/deb');assert.equal(stableDeb.suggestedName, 'Fluxer-2026.910.101500-linux-amd64.deb');- assert.equal(canaryDeb.url, 'https://api.canary.fluxer.app/dl/desktop/canary/linux/x64/2026.910.101500/deb');+ assert.equal(canaryDeb.url, 'https://pkgs.fluxer.com/desktop/canary/linux/x64/2026.910.101500/deb');assert.equal(canaryDeb.suggestedName, 'Fluxer-Canary-2026.910.101500-linux-amd64.deb');});@@ -145,7 +145,7 @@ describe('UpdaterDownloads Linux manual update options', () => {const deb = options.find((option) => option.format === 'deb');assert.equal(deb.suggestedName, 'Fluxer-Canary-2026.908.173325-linux-amd64.deb');- assert.equal(deb.url, 'https://api.canary.fluxer.app/dl/desktop/canary/linux/x64/2026.908.173325/deb');+ assert.equal(deb.url, 'https://pkgs.fluxer.com/desktop/canary/linux/x64/2026.908.173325/deb');assert.equal(deb.sha256, DEB_SHA256);assert.equal(options.length, 4);for (const option of options) {@@ -156,7 +156,7 @@ describe('UpdaterDownloads Linux manual update options', () => {}assert.equal(getManualDownloadUrl(info),- 'https://api.canary.fluxer.app/dl/desktop/canary/linux/x64/2026.908.173325/appimage',+ 'https://pkgs.fluxer.com/desktop/canary/linux/x64/2026.908.173325/appimage',);});});@@ -173,7 +173,7 @@ describe('UpdaterDownloads manual download url', () => {assert.equal(getManualDownloadUrl(info),- 'https://api.fluxer.app/dl/desktop/stable/linux/x64/2026.910.101500/appimage',+ 'https://pkgs.fluxer.com/desktop/stable/linux/x64/2026.910.101500/appimage',);});diff --git a/fluxer_desktop/src/main/UpdaterDownloads.ts b/fluxer_desktop/src/main/UpdaterDownloads.tsindex 542528314..b72a39bf8 100644--- a/fluxer_desktop/src/main/UpdaterDownloads.ts+++ b/fluxer_desktop/src/main/UpdaterDownloads.ts@@ -17,8 +17,8 @@ function getDesktopDownloadArch(arch: NodeJS.Architecture): DesktopDownloadArch}const DESKTOP_DOWNLOAD_ARCH = getDesktopDownloadArch(process.arch);-const UPDATE_API_ENDPOINT = BUILD_CHANNEL === 'canary' ? 'https://api.canary.fluxer.app' : 'https://api.fluxer.app';-export const UPDATE_BASE_URL = `${UPDATE_API_ENDPOINT}/dl/desktop/${BUILD_CHANNEL}/${process.platform}/${DESKTOP_DOWNLOAD_ARCH}`;+const PKGS_BASE_URL = 'https://pkgs.fluxer.com';+export const UPDATE_BASE_URL = `${PKGS_BASE_URL}/desktop/${BUILD_CHANNEL}/${process.platform}/${DESKTOP_DOWNLOAD_ARCH}`;export const DOWNLOAD_PAGE_URL =BUILD_CHANNEL === 'canary' ? 'https://canary.fluxer.app/download' : 'https://fluxer.app/download';@@ -72,7 +72,7 @@ function isLinuxManualDesktopFormat(format: ManualDesktopFormat): format is Linureturn format === 'appimage' || format === 'deb' || format === 'rpm' || format === 'tar_gz';}-function buildManualVersionDownloadUrl(version: string, format: ManualDesktopFormat): string {+export function buildManualVersionDownloadUrl(version: string, format: ManualDesktopFormat): string {return `${UPDATE_BASE_URL}/${version}/${format}`;}diff --git a/fluxer_desktop/src/preload/index.ts b/fluxer_desktop/src/preload/index.tsindex da8ad2130..c67954eff 100644--- a/fluxer_desktop/src/preload/index.ts+++ b/fluxer_desktop/src/preload/index.ts@@ -444,8 +444,8 @@ const api: ElectronAPI = {ipcRenderer.invoke('mac-tcc:status', 'screen-recording'),requestScreenRecordingPermission: (): Promise<InputMonitoringPermissionStatus> =>ipcRenderer.invoke('mac-tcc:request', 'screen-recording'),- downloadFile: (url: string, defaultPath: string): Promise<DownloadFileResult> =>- ipcRenderer.invoke('download-file', {url, defaultPath}),+ downloadFile: (url: string, defaultPath: string, sha256?: string | null): Promise<DownloadFileResult> =>+ ipcRenderer.invoke('download-file', {url, defaultPath, sha256}),passkeyIsSupported: (): Promise<boolean> => ipcRenderer.invoke('passkey-is-supported'),passkeyAuthenticate: (options: PublicKeyCredentialRequestOptionsJSON,