chore(main): release 4.9.3 (#1495)

🤖 I have created a release *beep* *boop*
---


## [4.9.3](https://github.com/unraid/api/compare/v4.9.2...v4.9.3)
(2025-07-09)


### Bug Fixes

* duplicated header logo after api stops
([#1493](https://github.com/unraid/api/issues/1493))
([4168f43](4168f43e3e))

---
This PR was generated with [Release
Please](https://github.com/googleapis/release-please). See
[documentation](https://github.com/googleapis/release-please#release-please).

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>

.claude/settings.local.json

@@ -2,7 +2,16 @@
   "permissions": {
     "allow": [
       "Bash(rg:*)",
-      "Bash(find:*)"
+      "Bash(find:*)",
+      "Bash(pnpm codegen:*)",
+      "Bash(pnpm dev:*)",
+      "Bash(pnpm build:*)",
+      "Bash(pnpm test:*)",
+      "Bash(grep:*)",
+      "Bash(pnpm type-check:*)",
+      "Bash(pnpm lint:*)",
+      "Bash(pnpm --filter ./api lint)",
+      "Bash(mv:*)"
     ]
   },
   "enableAllProjectMcpServers": false

.github/workflows/release-production.yml

@@ -32,7 +32,9 @@ jobs:
         with:
           node-version: '22.17.0'
       - run: |
-          echo '${{ steps.release-info.outputs.body }}' >> release-notes.txt
+          cat << 'EOF' > release-notes.txt
+          ${{ steps.release-info.outputs.body }}
+          EOF
       - run: npm install html-escaper@2 xml2js
       - name: Update Plugin Changelog
         uses: actions/github-script@v7

.release-please-manifest.json

@@ -1 +1 @@
-{".":"4.9.0"}
+{".":"4.9.3"}

api/CHANGELOG.md

@@ -1,5 +1,29 @@
 # Changelog
 
+## [4.9.3](https://github.com/unraid/api/compare/v4.9.2...v4.9.3) (2025-07-09)
+
+
+### Bug Fixes
+
+* duplicated header logo after api stops ([#1493](https://github.com/unraid/api/issues/1493)) ([4168f43](https://github.com/unraid/api/commit/4168f43e3ecd51479bec3aae585abbe6dcd3e416))
+
+## [4.9.2](https://github.com/unraid/api/compare/v4.9.1...v4.9.2) (2025-07-09)
+
+
+### Bug Fixes
+
+* invalid configs no longer crash API ([#1491](https://github.com/unraid/api/issues/1491)) ([6bf3f77](https://github.com/unraid/api/commit/6bf3f776380edeff5133517e6aca223556e30144))
+* invalid state for unraid plugin ([#1492](https://github.com/unraid/api/issues/1492)) ([39b8f45](https://github.com/unraid/api/commit/39b8f453da23793ef51f8e7f7196370aada8c5aa))
+* release note escaping ([5b6bcb6](https://github.com/unraid/api/commit/5b6bcb6043a5269bff4dc28714d787a5a3f07e22))
+
+## [4.9.1](https://github.com/unraid/api/compare/v4.9.0...v4.9.1) (2025-07-08)
+
+
+### Bug Fixes
+
+* **HeaderOsVersion:** adjust top margin for header component ([#1485](https://github.com/unraid/api/issues/1485)) ([862b54d](https://github.com/unraid/api/commit/862b54de8cd793606f1d29e76c19d4a0e1ae172f))
+* sign out doesn't work ([#1486](https://github.com/unraid/api/issues/1486)) ([f3671c3](https://github.com/unraid/api/commit/f3671c3e0750b79be1f19655a07a0e9932289b3f))
+
 ## [4.9.0](https://github.com/unraid/api/compare/v4.8.0...v4.9.0) (2025-07-08)
 
 

api/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@unraid/api",
-    "version": "4.9.0",
+    "version": "4.9.3",
     "main": "src/cli/index.ts",
     "type": "module",
     "corepack": {

api/src/core/utils/misc/parse-config.ts

@@ -124,7 +124,15 @@ export const parseConfig = <T extends Record<string, any>>(
         throw new AppError('Invalid Parameters Passed to ParseConfig');
     }
 
-    const data: Record<string, any> = parseIni(fileContents);
+    let data: Record<string, any>;
+    try {
+        data = parseIni(fileContents);
+    } catch (error) {
+        throw new AppError(
+            `Failed to parse config file: ${error instanceof Error ? error.message : String(error)}`
+        );
+    }
+
     // Remove quotes around keys
     const dataWithoutQuoteKeys = Object.fromEntries(
         Object.entries(data).map(([key, value]) => [key.replace(/^"(.+(?="$))"$/, '$1'), value])

api/src/unraid-api/config/api-config.module.ts

@@ -12,6 +12,8 @@ import { ConfigPersistenceHelper } from '@app/unraid-api/config/persistence.help
 
 export { type ApiConfig };
 
+const logger = new Logger('ApiConfig');
+
 const createDefaultConfig = (): ApiConfig => ({
     version: API_VERSION,
     extraOrigins: [],
@@ -33,21 +35,54 @@ export const persistApiConfig = async (config: ApiConfig) => {
 };
 
 export const loadApiConfig = async () => {
-    const defaultConfig = createDefaultConfig();
-    const apiConfig = new ApiStateConfig<ApiConfig>(
-        {
-            name: 'api',
-            defaultConfig,
-            parse: (data) => data as ApiConfig,
-        },
-        new ConfigPersistenceHelper()
-    );
-    const diskConfig = await apiConfig.parseConfig();
-    return {
-        ...defaultConfig,
-        ...diskConfig,
-        version: API_VERSION,
-    };
+    try {
+        const defaultConfig = createDefaultConfig();
+        const apiConfig = new ApiStateConfig<ApiConfig>(
+            {
+                name: 'api',
+                defaultConfig,
+                parse: (data) => data as ApiConfig,
+            },
+            new ConfigPersistenceHelper()
+        );
+
+        let diskConfig: ApiConfig | undefined;
+        try {
+            diskConfig = await apiConfig.parseConfig();
+        } catch (error) {
+            logger.error('Failed to load API config from disk, using defaults:', error);
+            diskConfig = undefined;
+
+            // Try to overwrite the invalid config with defaults to fix the issue
+            try {
+                const configToWrite = {
+                    ...defaultConfig,
+                    version: API_VERSION,
+                };
+
+                const writeSuccess = await apiConfig.persist(configToWrite);
+                if (writeSuccess) {
+                    logger.log('Successfully overwrote invalid config file with defaults.');
+                } else {
+                    logger.error(
+                        'Failed to overwrite invalid config file. Continuing with defaults in memory only.'
+                    );
+                }
+            } catch (persistError) {
+                logger.error('Error during config file repair:', persistError);
+            }
+        }
+
+        return {
+            ...defaultConfig,
+            ...diskConfig,
+            version: API_VERSION,
+        };
+    } catch (outerError) {
+        // This should never happen, but ensures the config factory never throws
+        logger.error('Critical error in loadApiConfig, using minimal defaults:', outerError);
+        return createDefaultConfig();
+    }
 };
 
 /**
@@ -81,21 +116,29 @@ export class ApiConfigPersistence {
     }
 
     async onModuleInit() {
-        if (!(await fileExists(this.filePath))) {
-            this.migrateFromMyServersConfig();
+        try {
+            if (!(await fileExists(this.filePath))) {
+                this.migrateFromMyServersConfig();
+            }
+            await this.persistenceHelper.persistIfChanged(this.filePath, this.config);
+            this.configService.changes$.pipe(bufferTime(25)).subscribe({
+                next: async (changes) => {
+                    if (changes.some((change) => change.path.startsWith('api'))) {
+                        this.logger.verbose(`API Config changed ${JSON.stringify(changes)}`);
+                        try {
+                            await this.persistenceHelper.persistIfChanged(this.filePath, this.config);
+                        } catch (persistError) {
+                            this.logger.error('Error persisting config changes:', persistError);
+                        }
+                    }
+                },
+                error: (err) => {
+                    this.logger.error('Error receiving config changes:', err);
+                },
+            });
+        } catch (error) {
+            this.logger.error('Error during API config module initialization:', error);
         }
-        await this.persistenceHelper.persistIfChanged(this.filePath, this.config);
-        this.configService.changes$.pipe(bufferTime(25)).subscribe({
-            next: async (changes) => {
-                if (changes.some((change) => change.path.startsWith('api'))) {
-                    this.logger.verbose(`API Config changed ${JSON.stringify(changes)}`);
-                    await this.persistenceHelper.persistIfChanged(this.filePath, this.config);
-                }
-            },
-            error: (err) => {
-                this.logger.error('Error receiving config changes:', err);
-            },
-        });
     }
 
     convertLegacyConfig(

api/src/unraid-api/config/api-config.test.ts

@@ -2,9 +2,26 @@ import { ConfigService } from '@nestjs/config';
 
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 
-import { ApiConfigPersistence } from '@app/unraid-api/config/api-config.module.js';
+import { fileExists } from '@app/core/utils/files/file-exists.js';
+import { ApiConfigPersistence, loadApiConfig } from '@app/unraid-api/config/api-config.module.js';
 import { ConfigPersistenceHelper } from '@app/unraid-api/config/persistence.helper.js';
 
+// Mock the core file-exists utility used by ApiStateConfig
+vi.mock('@app/core/utils/files/file-exists.js', () => ({
+    fileExists: vi.fn(),
+}));
+
+// Mock the shared file-exists utility used by ConfigPersistenceHelper
+vi.mock('@unraid/shared/util/file.js', () => ({
+    fileExists: vi.fn(),
+}));
+
+// Mock fs/promises for file I/O operations
+vi.mock('fs/promises', () => ({
+    readFile: vi.fn(),
+    writeFile: vi.fn(),
+}));
+
 describe('ApiConfigPersistence', () => {
     let service: ApiConfigPersistence;
     let configService: ConfigService;
@@ -135,3 +152,127 @@ describe('ApiConfigPersistence', () => {
         });
     });
 });
+
+describe('loadApiConfig', () => {
+    let readFile: any;
+    let writeFile: any;
+
+    beforeEach(async () => {
+        vi.clearAllMocks();
+        // Reset modules to ensure fresh imports
+        vi.resetModules();
+
+        // Get mocked functions
+        const fsMocks = await import('fs/promises');
+        readFile = fsMocks.readFile;
+        writeFile = fsMocks.writeFile;
+    });
+
+    it('should return default config when file does not exist', async () => {
+        vi.mocked(fileExists).mockResolvedValue(false);
+
+        const result = await loadApiConfig();
+
+        expect(result).toEqual({
+            version: expect.any(String),
+            extraOrigins: [],
+            sandbox: false,
+            ssoSubIds: [],
+            plugins: [],
+        });
+    });
+
+    it('should merge disk config with defaults when file exists', async () => {
+        const diskConfig = {
+            extraOrigins: ['https://example.com'],
+            sandbox: true,
+            ssoSubIds: ['sub1', 'sub2'],
+        };
+
+        vi.mocked(fileExists).mockResolvedValue(true);
+        vi.mocked(readFile).mockResolvedValue(JSON.stringify(diskConfig));
+
+        const result = await loadApiConfig();
+
+        expect(result).toEqual({
+            version: expect.any(String),
+            extraOrigins: ['https://example.com'],
+            sandbox: true,
+            ssoSubIds: ['sub1', 'sub2'],
+            plugins: [],
+        });
+    });
+
+    it('should use default config and overwrite file when JSON parsing fails', async () => {
+        const { fileExists: sharedFileExists } = await import('@unraid/shared/util/file.js');
+
+        vi.mocked(fileExists).mockResolvedValue(true);
+        vi.mocked(readFile).mockResolvedValue('{ invalid json }');
+        vi.mocked(sharedFileExists).mockResolvedValue(false); // For persist operation
+        vi.mocked(writeFile).mockResolvedValue(undefined);
+
+        const result = await loadApiConfig();
+
+        // Error logging is handled by NestJS Logger, just verify the config is returned
+        expect(writeFile).toHaveBeenCalled();
+        expect(result).toEqual({
+            version: expect.any(String),
+            extraOrigins: [],
+            sandbox: false,
+            ssoSubIds: [],
+            plugins: [],
+        });
+    });
+
+    it('should handle write failure gracefully when JSON parsing fails', async () => {
+        const { fileExists: sharedFileExists } = await import('@unraid/shared/util/file.js');
+
+        vi.mocked(fileExists).mockResolvedValue(true);
+        vi.mocked(readFile).mockResolvedValue('{ invalid json }');
+        vi.mocked(sharedFileExists).mockResolvedValue(false); // For persist operation
+        vi.mocked(writeFile).mockRejectedValue(new Error('Permission denied'));
+
+        const result = await loadApiConfig();
+
+        // Error logging is handled by NestJS Logger, just verify the config is returned
+        expect(writeFile).toHaveBeenCalled();
+        expect(result).toEqual({
+            version: expect.any(String),
+            extraOrigins: [],
+            sandbox: false,
+            ssoSubIds: [],
+            plugins: [],
+        });
+    });
+
+    it('should use default config when file is empty', async () => {
+        vi.mocked(fileExists).mockResolvedValue(true);
+        vi.mocked(readFile).mockResolvedValue('');
+
+        const result = await loadApiConfig();
+
+        // No error logging expected for empty files
+        expect(result).toEqual({
+            version: expect.any(String),
+            extraOrigins: [],
+            sandbox: false,
+            ssoSubIds: [],
+            plugins: [],
+        });
+    });
+
+    it('should always override version with current API_VERSION', async () => {
+        const diskConfig = {
+            version: 'old-version',
+            extraOrigins: ['https://example.com'],
+        };
+
+        vi.mocked(fileExists).mockResolvedValue(true);
+        vi.mocked(readFile).mockResolvedValue(JSON.stringify(diskConfig));
+
+        const result = await loadApiConfig();
+
+        expect(result.version).not.toBe('old-version');
+        expect(result.version).toBeTruthy();
+    });
+});

api/src/unraid-api/config/factory/api-state.model.test.ts

@@ -0,0 +1,364 @@
+import { Logger } from '@nestjs/common';
+import { readFile } from 'node:fs/promises';
+import { join } from 'path';
+
+import type { Mock } from 'vitest';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { fileExists } from '@app/core/utils/files/file-exists.js';
+import { ApiStateConfig } from '@app/unraid-api/config/factory/api-state.model.js';
+import { ConfigPersistenceHelper } from '@app/unraid-api/config/persistence.helper.js';
+
+vi.mock('node:fs/promises');
+vi.mock('@app/core/utils/files/file-exists.js');
+vi.mock('@app/environment.js', () => ({
+    PATHS_CONFIG_MODULES: '/test/config/path',
+}));
+
+describe('ApiStateConfig', () => {
+    let mockPersistenceHelper: ConfigPersistenceHelper;
+    let mockLogger: Logger;
+
+    interface TestConfig {
+        name: string;
+        value: number;
+        enabled: boolean;
+    }
+
+    const defaultConfig: TestConfig = {
+        name: 'test',
+        value: 42,
+        enabled: true,
+    };
+
+    const parseFunction = (data: unknown): TestConfig => {
+        if (!data || typeof data !== 'object') {
+            throw new Error('Invalid config format');
+        }
+        return data as TestConfig;
+    };
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+
+        mockPersistenceHelper = {
+            persistIfChanged: vi.fn().mockResolvedValue(true),
+        } as any;
+
+        mockLogger = {
+            log: vi.fn(),
+            warn: vi.fn(),
+            error: vi.fn(),
+            debug: vi.fn(),
+        } as any;
+
+        vi.spyOn(Logger.prototype, 'log').mockImplementation(mockLogger.log);
+        vi.spyOn(Logger.prototype, 'warn').mockImplementation(mockLogger.warn);
+        vi.spyOn(Logger.prototype, 'error').mockImplementation(mockLogger.error);
+        vi.spyOn(Logger.prototype, 'debug').mockImplementation(mockLogger.debug);
+    });
+
+    describe('constructor', () => {
+        it('should initialize with cloned default config', () => {
+            const config = new ApiStateConfig(
+                {
+                    name: 'test-config',
+                    defaultConfig,
+                    parse: parseFunction,
+                },
+                mockPersistenceHelper
+            );
+
+            expect(config.config).toEqual(defaultConfig);
+            expect(config.config).not.toBe(defaultConfig);
+        });
+    });
+
+    describe('token', () => {
+        it('should generate correct token', () => {
+            const config = new ApiStateConfig(
+                {
+                    name: 'my-config',
+                    defaultConfig,
+                    parse: parseFunction,
+                },
+                mockPersistenceHelper
+            );
+
+            expect(config.token).toBe('ApiConfig.my-config');
+        });
+    });
+
+    describe('file paths', () => {
+        it('should generate correct file name', () => {
+            const config = new ApiStateConfig(
+                {
+                    name: 'test-config',
+                    defaultConfig,
+                    parse: parseFunction,
+                },
+                mockPersistenceHelper
+            );
+
+            expect(config.fileName).toBe('test-config.json');
+        });
+
+        it('should generate correct file path', () => {
+            const config = new ApiStateConfig(
+                {
+                    name: 'test-config',
+                    defaultConfig,
+                    parse: parseFunction,
+                },
+                mockPersistenceHelper
+            );
+
+            expect(config.filePath).toBe(join('/test/config/path', 'test-config.json'));
+        });
+    });
+
+    describe('parseConfig', () => {
+        let config: ApiStateConfig<TestConfig>;
+
+        beforeEach(() => {
+            config = new ApiStateConfig(
+                {
+                    name: 'test-config',
+                    defaultConfig,
+                    parse: parseFunction,
+                },
+                mockPersistenceHelper
+            );
+        });
+
+        it('should return undefined when file does not exist', async () => {
+            (fileExists as Mock).mockResolvedValue(false);
+
+            const result = await config.parseConfig();
+
+            expect(result).toBeUndefined();
+            expect(readFile).not.toHaveBeenCalled();
+        });
+
+        it('should parse valid JSON config', async () => {
+            const validConfig = { name: 'custom', value: 100, enabled: false };
+            (fileExists as Mock).mockResolvedValue(true);
+            (readFile as Mock).mockResolvedValue(JSON.stringify(validConfig));
+
+            const result = await config.parseConfig();
+
+            expect(result).toEqual(validConfig);
+            expect(readFile).toHaveBeenCalledWith(config.filePath, 'utf8');
+        });
+
+        it('should return undefined for empty file', async () => {
+            (fileExists as Mock).mockResolvedValue(true);
+            (readFile as Mock).mockResolvedValue('');
+
+            const result = await config.parseConfig();
+
+            expect(result).toBeUndefined();
+            expect(mockLogger.warn).toHaveBeenCalledWith(expect.stringContaining('is empty'));
+        });
+
+        it('should return undefined for whitespace-only file', async () => {
+            (fileExists as Mock).mockResolvedValue(true);
+            (readFile as Mock).mockResolvedValue('   \n\t  ');
+
+            const result = await config.parseConfig();
+
+            expect(result).toBeUndefined();
+            expect(mockLogger.warn).toHaveBeenCalledWith(expect.stringContaining('is empty'));
+        });
+
+        it('should throw error for invalid JSON', async () => {
+            (fileExists as Mock).mockResolvedValue(true);
+            (readFile as Mock).mockResolvedValue('{ invalid json }');
+
+            await expect(config.parseConfig()).rejects.toThrow();
+            expect(mockLogger.error).toHaveBeenCalledWith(
+                expect.stringContaining('Failed to parse JSON')
+            );
+            expect(mockLogger.debug).toHaveBeenCalledWith(expect.stringContaining('{ invalid json }'));
+        });
+
+        it('should throw error for incomplete JSON', async () => {
+            (fileExists as Mock).mockResolvedValue(true);
+            (readFile as Mock).mockResolvedValue('{ "name": "test"');
+
+            await expect(config.parseConfig()).rejects.toThrow();
+            expect(mockLogger.error).toHaveBeenCalledWith(
+                expect.stringContaining('Failed to parse JSON')
+            );
+        });
+
+        it('should use custom file path when provided', async () => {
+            const customPath = '/custom/path/config.json';
+            (fileExists as Mock).mockResolvedValue(true);
+            (readFile as Mock).mockResolvedValue(JSON.stringify(defaultConfig));
+
+            await config.parseConfig({ filePath: customPath });
+
+            expect(fileExists).toHaveBeenCalledWith(customPath);
+            expect(readFile).toHaveBeenCalledWith(customPath, 'utf8');
+        });
+    });
+
+    describe('persist', () => {
+        let config: ApiStateConfig<TestConfig>;
+
+        beforeEach(() => {
+            config = new ApiStateConfig(
+                {
+                    name: 'test-config',
+                    defaultConfig,
+                    parse: parseFunction,
+                },
+                mockPersistenceHelper
+            );
+        });
+
+        it('should persist current config when no argument provided', async () => {
+            const result = await config.persist();
+
+            expect(result).toBe(true);
+            expect(mockPersistenceHelper.persistIfChanged).toHaveBeenCalledWith(
+                config.filePath,
+                defaultConfig
+            );
+        });
+
+        it('should persist provided config', async () => {
+            const customConfig = { name: 'custom', value: 999, enabled: false };
+
+            const result = await config.persist(customConfig);
+
+            expect(result).toBe(true);
+            expect(mockPersistenceHelper.persistIfChanged).toHaveBeenCalledWith(
+                config.filePath,
+                customConfig
+            );
+        });
+
+        it('should return false and log error on persistence failure', async () => {
+            (mockPersistenceHelper.persistIfChanged as Mock).mockResolvedValue(false);
+
+            const result = await config.persist();
+
+            expect(result).toBe(false);
+            expect(mockLogger.error).toHaveBeenCalledWith(
+                expect.stringContaining('Could not write config')
+            );
+        });
+    });
+
+    describe('load', () => {
+        let config: ApiStateConfig<TestConfig>;
+
+        beforeEach(() => {
+            config = new ApiStateConfig(
+                {
+                    name: 'test-config',
+                    defaultConfig,
+                    parse: parseFunction,
+                },
+                mockPersistenceHelper
+            );
+        });
+
+        it('should load config from file when it exists', async () => {
+            const savedConfig = { name: 'saved', value: 200, enabled: true };
+            (fileExists as Mock).mockResolvedValue(true);
+            (readFile as Mock).mockResolvedValue(JSON.stringify(savedConfig));
+
+            await config.load();
+
+            expect(config.config).toEqual(savedConfig);
+        });
+
+        it('should create default config when file does not exist', async () => {
+            (fileExists as Mock).mockResolvedValue(false);
+
+            await config.load();
+
+            expect(config.config).toEqual(defaultConfig);
+            expect(mockLogger.log).toHaveBeenCalledWith(
+                expect.stringContaining('Config file does not exist')
+            );
+            expect(mockPersistenceHelper.persistIfChanged).toHaveBeenCalledWith(
+                config.filePath,
+                defaultConfig
+            );
+        });
+
+        it('should not modify config when file is invalid', async () => {
+            (fileExists as Mock).mockResolvedValue(true);
+            (readFile as Mock).mockResolvedValue('invalid json');
+
+            await config.load();
+
+            expect(config.config).toEqual(defaultConfig);
+            expect(mockLogger.warn).toHaveBeenCalledWith(
+                expect.any(Error),
+                expect.stringContaining('is invalid')
+            );
+        });
+
+        it('should not throw even when persist fails', async () => {
+            (fileExists as Mock).mockResolvedValue(false);
+            (mockPersistenceHelper.persistIfChanged as Mock).mockResolvedValue(false);
+
+            await expect(config.load()).resolves.not.toThrow();
+
+            expect(config.config).toEqual(defaultConfig);
+        });
+    });
+
+    describe('update', () => {
+        let config: ApiStateConfig<TestConfig>;
+
+        beforeEach(() => {
+            config = new ApiStateConfig(
+                {
+                    name: 'test-config',
+                    defaultConfig,
+                    parse: parseFunction,
+                },
+                mockPersistenceHelper
+            );
+        });
+
+        it('should update config with partial values', () => {
+            config.update({ value: 123 });
+
+            expect(config.config).toEqual({
+                name: 'test',
+                value: 123,
+                enabled: true,
+            });
+        });
+
+        it('should return self for chaining', () => {
+            const result = config.update({ enabled: false });
+
+            expect(result).toBe(config);
+        });
+
+        it('should validate updated config through parse function', () => {
+            const badParseFunction = vi.fn().mockImplementation(() => {
+                throw new Error('Validation failed');
+            });
+
+            const strictConfig = new ApiStateConfig(
+                {
+                    name: 'strict-config',
+                    defaultConfig,
+                    parse: badParseFunction,
+                },
+                mockPersistenceHelper
+            );
+
+            expect(() => strictConfig.update({ value: -1 })).toThrow('Validation failed');
+        });
+    });
+});

api/src/unraid-api/config/factory/api-state.model.ts

@@ -56,13 +56,11 @@ export class ApiStateConfig<T> {
      * @returns True if the config was written successfully, false otherwise.
      */
     async persist(config = this.#config) {
-        try {
-            await this.persistenceHelper.persistIfChanged(this.filePath, config);
-            return true;
-        } catch (error) {
-            this.logger.error(error, `Could not write config to ${this.filePath}.`);
-            return false;
+        const success = await this.persistenceHelper.persistIfChanged(this.filePath, config);
+        if (!success) {
+            this.logger.error(`Could not write config to ${this.filePath}.`);
         }
+        return success;
     }
 
     /**
@@ -76,8 +74,23 @@ export class ApiStateConfig<T> {
         const { filePath = this.filePath } = opts;
         if (!(await fileExists(filePath))) return undefined;
 
-        const rawConfig = JSON.parse(await readFile(filePath, 'utf8'));
-        return this.options.parse(rawConfig);
+        const fileContent = await readFile(filePath, 'utf8');
+
+        if (!fileContent || fileContent.trim() === '') {
+            this.logger.warn(`Config file '${filePath}' is empty.`);
+            return undefined;
+        }
+
+        try {
+            const rawConfig = JSON.parse(fileContent);
+            return this.options.parse(rawConfig);
+        } catch (error) {
+            this.logger.error(
+                `Failed to parse JSON from '${filePath}': ${error instanceof Error ? error.message : String(error)}`
+            );
+            this.logger.debug(`File content: ${fileContent.substring(0, 100)}...`);
+            throw error;
+        }
     }
 
     /**

api/src/unraid-api/config/persistence.helper.ts

@@ -12,24 +12,59 @@ export class ConfigPersistenceHelper {
      *
      * @param filePath - The path to the config file.
      * @param data - The data to persist.
-     * @returns `true` if the config was persisted, `false` otherwise.
+     * @returns `true` if the config was persisted, `false` if no changes were needed or if persistence failed.
      *
-     * @throws {Error} if the config file does not exist or is unreadable.
-     * @throws {Error} if the config file is not valid JSON.
-     * @throws {Error} if given data is not JSON (de)serializable.
-     * @throws {Error} if the config file is not writable.
+     * This method is designed to never throw errors. If the existing file is corrupted or unreadable,
+     * it will attempt to overwrite it with the new data. If write operations fail, it returns false
+     * but does not crash the application.
      */
     async persistIfChanged(filePath: string, data: unknown): Promise<boolean> {
         if (!(await fileExists(filePath))) {
-            await writeFile(filePath, JSON.stringify(data ?? {}, null, 2));
-            return true;
+            try {
+                const jsonString = JSON.stringify(data ?? {}, null, 2);
+                await writeFile(filePath, jsonString);
+                return true;
+            } catch (error) {
+                // JSON serialization or write failed, but don't crash - just return false
+                return false;
+            }
         }
-        const currentData = JSON.parse(await readFile(filePath, 'utf8'));
-        const stagedData = JSON.parse(JSON.stringify(data));
+
+        let currentData: unknown;
+        try {
+            const fileContent = await readFile(filePath, 'utf8');
+            currentData = JSON.parse(fileContent);
+        } catch (error) {
+            // If existing file is corrupted, treat it as if it doesn't exist
+            // and write the new data
+            try {
+                const jsonString = JSON.stringify(data ?? {}, null, 2);
+                await writeFile(filePath, jsonString);
+                return true;
+            } catch (writeError) {
+                // JSON serialization or write failed, but don't crash - just return false
+                return false;
+            }
+        }
+
+        let stagedData: unknown;
+        try {
+            stagedData = JSON.parse(JSON.stringify(data));
+        } catch (error) {
+            // If data can't be serialized to JSON, we can't persist it
+            return false;
+        }
+
         if (isEqual(currentData, stagedData)) {
             return false;
         }
-        await writeFile(filePath, JSON.stringify(stagedData, null, 2));
-        return true;
+
+        try {
+            await writeFile(filePath, JSON.stringify(stagedData, null, 2));
+            return true;
+        } catch (error) {
+            // Write failed, but don't crash - just return false
+            return false;
+        }
     }
 }

api/src/unraid-api/plugin/plugin.service.ts

@@ -65,7 +65,16 @@ export class PluginService {
      * @returns A tuple of the plugin name and version.
      */
     static async listPlugins(): Promise<[string, string][]> {
-        const { plugins = [] } = await loadApiConfig();
+        let plugins: string[] = [];
+        try {
+            const config = await loadApiConfig();
+            plugins = config.plugins || [];
+        } catch (error) {
+            PluginService.logger.error(
+                'Failed to load API config for plugin discovery, using empty list:',
+                error
+            );
+        }
         const pluginNames = new Set(
             plugins.map((plugin) => {
                 const { name } = parsePackageArg(plugin);

api/src/unraid-api/unraid-file-modifier/modifications/__test__/snapshots/DefaultPageLayout.php.modified.snapshot.php

@@ -711,7 +711,7 @@ $.ajaxPrefilter(function(s, orig, xhr){
   <div class="upgrade_notice" style="display:none"></div>
   <div id="header" class="<?=$display['banner']?>">
     <div class="logo">
-      
+      <a href="https://unraid.net" target="_blank"><?readfile("$docroot/webGui/images/UN-logotype-gradient.svg")?></a>
       <unraid-i18n-host><unraid-header-os-version></unraid-header-os-version></unraid-i18n-host>
     </div>
     <?include "$docroot/plugins/dynamix.my.servers/include/myservers2.php"?>

api/src/unraid-api/unraid-file-modifier/modifications/default-page-layout.modification.ts

@@ -65,13 +65,6 @@ if (is_localhost() && !is_good_session()) {
         return this.prependDoctypeWithPhp(source, newPhpCode);
     }
 
-    private hideHeaderLogo(source: string): string {
-        return source.replace(
-            '<a href="https://unraid.net" target="_blank"><?readfile("$docroot/webGui/images/UN-logotype-gradient.svg")?></a>',
-            ''
-        );
-    }
-
     private addModalsWebComponent(source: string): string {
         return source.replace('<body>', '<body>\n<unraid-modals></unraid-modals>');
     }
@@ -81,7 +74,6 @@ if (is_localhost() && !is_good_session()) {
             this.replaceToasts.bind(this),
             this.addToaster.bind(this),
             this.patchGuiBootAuth.bind(this),
-            this.hideHeaderLogo.bind(this),
             this.addModalsWebComponent.bind(this),
         ];
 

api/src/unraid-api/unraid-file-modifier/modifications/patches/default-page-layout.patch

@@ -53,7 +53,7 @@ Index: /usr/local/emhttp/plugins/dynamix/include/DefaultPageLayout.php
  }
  
  function closeNotifier() {
-@@ -695,15 +704,16 @@
+@@ -695,10 +704,11 @@
  });
  </script>
  <?include "$docroot/plugins/dynamix.my.servers/include/myservers1.php"?>
@@ -64,13 +64,7 @@ Index: /usr/local/emhttp/plugins/dynamix/include/DefaultPageLayout.php
    <div class="upgrade_notice" style="display:none"></div>
    <div id="header" class="<?=$display['banner']?>">
      <div class="logo">
--      <a href="https://unraid.net" target="_blank"><?readfile("$docroot/webGui/images/UN-logotype-gradient.svg")?></a>
-+      
-       <unraid-i18n-host><unraid-header-os-version></unraid-header-os-version></unraid-i18n-host>
-     </div>
-     <?include "$docroot/plugins/dynamix.my.servers/include/myservers2.php"?>
-   </div>
-   <a href="#" class="move_to_end" title="<?=_('Move To End')?>"><i class="fa fa-arrow-circle-down"></i></a>
+       <a href="https://unraid.net" target="_blank"><?readfile("$docroot/webGui/images/UN-logotype-gradient.svg")?></a>
 @@ -748,12 +758,12 @@
    }
    // create list of nchan scripts to be started

package.json

@@ -1,7 +1,7 @@
 {
   "name": "unraid-monorepo",
   "private": true,
-  "version": "4.9.0",
+  "version": "4.9.3",
   "scripts": {
     "build": "pnpm -r build",
     "build:watch": " pnpm -r --parallel build:watch",

packages/unraid-api-plugin-connect/src/config/connect-status-writer.service.ts

@@ -0,0 +1,69 @@
+import { Injectable, Logger, OnModuleInit } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { writeFile } from 'fs/promises';
+
+import { ConnectionMetadata, ConfigType } from './connect.config.js';
+
+@Injectable()
+export class ConnectStatusWriterService implements OnModuleInit {
+    constructor(private readonly configService: ConfigService<ConfigType, true>) {}
+
+    private logger = new Logger(ConnectStatusWriterService.name);
+
+    get statusFilePath() {
+        // Write to /var/local/emhttp/connectStatus.json so PHP can read it
+        return '/var/local/emhttp/connectStatus.json';
+    }
+
+    async onModuleInit() {
+        this.logger.verbose(`Status file path: ${this.statusFilePath}`);
+        
+        // Write initial status
+        await this.writeStatus();
+        
+        // Listen for changes to connection status
+        this.configService.changes$.subscribe({
+            next: async (change) => {
+                const connectionChanged = change.path && change.path.startsWith('connect.mothership');
+                if (connectionChanged) {
+                    await this.writeStatus();
+                }
+            },
+            error: (err) => {
+                this.logger.error('Error receiving config changes:', err);
+            },
+        });
+    }
+
+    private async writeStatus() {
+        try {
+            const connectionMetadata = this.configService.get<ConnectionMetadata>('connect.mothership');
+            
+            // Try to get allowed origins from the store
+            let allowedOrigins = '';
+            try {
+                // We can't import from @app here, so we'll skip allowed origins for now
+                // This can be added later if needed
+                allowedOrigins = '';
+            } catch (error) {
+                this.logger.debug('Could not get allowed origins:', error);
+            }
+            
+            const statusData = {
+                connectionStatus: connectionMetadata?.status || 'PRE_INIT',
+                error: connectionMetadata?.error || null,
+                lastPing: connectionMetadata?.lastPing || null,
+                allowedOrigins: allowedOrigins,
+                timestamp: Date.now()
+            };
+
+            const data = JSON.stringify(statusData, null, 2);
+            this.logger.verbose(`Writing connection status: ${data}`);
+            
+            await writeFile(this.statusFilePath, data);
+            this.logger.verbose(`Status written to ${this.statusFilePath}`);
+        } catch (error) {
+            this.logger.error(error, `Error writing status to '${this.statusFilePath}'`);
+        }
+    }
+}

packages/unraid-api-plugin-connect/src/index.ts

@@ -3,6 +3,7 @@ import { ConfigModule, ConfigService } from '@nestjs/config';
 
 import { ConnectConfigPersister } from './config/config.persistence.js';
 import { configFeature } from './config/connect.config.js';
+import { ConnectStatusWriterService } from './config/connect-status-writer.service.js';
 import { MothershipModule } from './mothership-proxy/mothership.module.js';
 import { ConnectModule } from './unraid-connect/connect.module.js';
 
@@ -10,7 +11,7 @@ export const adapter = 'nestjs';
 
 @Module({
     imports: [ConfigModule.forFeature(configFeature), ConnectModule, MothershipModule],
-    providers: [ConnectConfigPersister],
+    providers: [ConnectConfigPersister, ConnectStatusWriterService],
     exports: [],
 })
 class ConnectPluginModule {

plugin/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unraid/connect-plugin",
-  "version": "4.9.0",
+  "version": "4.9.3",
   "private": true,
   "dependencies": {
     "commander": "14.0.0",

plugin/plugins/dynamix.unraid.net.plg

@@ -138,6 +138,29 @@ exit 0
     </INLINE>
   </FILE>
 
+  <FILE Run="/bin/bash" Method="install">
+    <INLINE>
+      <![CDATA[
+      echo "Patching header logo if necessary..."
+
+      # We do this here instead of via API FileModification to avoid undesirable
+      # rollback when the API is stopped.
+      #
+      # This is necessary on < 7.2 because the unraid-header-os-version web component
+      # that ships with the base OS only displayes the version, not the logo as well.
+      #
+      # Rolling back in this case (i.e when stopping the API) yields a duplicate logo
+      # that blocks interaction with the navigation menu.
+      
+      # Remove the old header logo from DefaultPageLayout.php if present
+      if [ -f "/usr/local/emhttp/plugins/dynamix/include/DefaultPageLayout.php" ]; then
+        sed -i 's|<a href="https://unraid.net" target="_blank"><?readfile("$docroot/webGui/images/UN-logotype-gradient.svg")?></a>||g' "/usr/local/emhttp/plugins/dynamix/include/DefaultPageLayout.php"
+      fi
+
+      ]]>
+    </INLINE>
+  </FILE>
+
   <FILE Run="/bin/bash" Method="remove">
     <INLINE>
       MAINNAME="&name;"

plugin/source/dynamix.unraid.net/usr/local/emhttp/plugins/dynamix.my.servers/include/UpdateFlashBackup.php

@@ -23,9 +23,16 @@ $myservers_flash_cfg_path='/boot/config/plugins/dynamix.my.servers/myservers.cfg
 $myservers = file_exists($myservers_flash_cfg_path) ? @parse_ini_file($myservers_flash_cfg_path,true) : [];
 $isRegistered = !empty($myservers['remote']['username']);
 
-$myservers_memory_cfg_path ='/var/local/emhttp/myservers.cfg';
-$mystatus = (file_exists($myservers_memory_cfg_path)) ? @parse_ini_file($myservers_memory_cfg_path) : [];
-$isConnected = (($mystatus['minigraph']??'')==='CONNECTED') ? true : false;
+// Read connection status from the new API status file
+$statusFilePath = '/var/local/emhttp/connectStatus.json';
+$connectionStatus = '';
+
+if (file_exists($statusFilePath)) {
+    $statusData = @json_decode(file_get_contents($statusFilePath), true);
+    $connectionStatus = $statusData['connectionStatus'] ?? '';
+}
+
+$isConnected = ($connectionStatus === 'CONNECTED') ? true : false;
 
 $flashbackup_ini = '/var/local/emhttp/flashbackup.ini';
 

plugin/source/dynamix.unraid.net/usr/local/emhttp/plugins/dynamix.my.servers/include/state.php

@@ -168,9 +168,8 @@ class ServerState
     private function getMyServersCfgValues()
     {
         /**
-         * @todo can we read this from somewhere other than the flash? Connect page uses this path and /boot/config/plugins/dynamix.my.servers/myservers.cfg…
-         * - $myservers_memory_cfg_path ='/var/local/emhttp/myservers.cfg';
-         * - $mystatus = (file_exists($myservers_memory_cfg_path)) ? @parse_ini_file($myservers_memory_cfg_path) : [];
+         * Memory config is now written by the new API to /usr/local/emhttp/state/myservers.cfg
+         * This contains runtime state including connection status.
          */
         $flashCfgPath = '/boot/config/plugins/dynamix.my.servers/myservers.cfg';
         $this->myServersFlashCfg = file_exists($flashCfgPath) ? @parse_ini_file($flashCfgPath, true) : [];
@@ -212,11 +211,19 @@ class ServerState
          * Include localhost in the test, but only display HTTP(S) URLs that do not include localhost.
          */
         $this->host = $_SERVER['HTTP_HOST'] ?? "unknown";
-        $memoryCfgPath = '/var/local/emhttp/myservers.cfg';
-        $this->myServersMemoryCfg = (file_exists($memoryCfgPath)) ? @parse_ini_file($memoryCfgPath) : [];
-        $this->myServersMiniGraphConnected = (($this->myServersMemoryCfg['minigraph'] ?? '') === 'CONNECTED');
+        // Read connection status and allowed origins from the new API status file
+        $statusFilePath = '/var/local/emhttp/connectStatus.json';
+        $connectionStatus = '';
+        $allowedOrigins = '';
+        
+        if (file_exists($statusFilePath)) {
+            $statusData = @json_decode(file_get_contents($statusFilePath), true);
+            $connectionStatus = $statusData['connectionStatus'] ?? '';
+            $allowedOrigins = $statusData['allowedOrigins'] ?? '';
+        }
+        
+        $this->myServersMiniGraphConnected = ($connectionStatus === 'CONNECTED');
 
-        $allowedOrigins = $this->myServersMemoryCfg['allowedOrigins'] ?? "";
         $extraOrigins = $this->myServersFlashCfg['api']['extraOrigins'] ?? "";
         $combinedOrigins = $allowedOrigins . "," . $extraOrigins; // combine the two strings for easier searching
         $combinedOrigins = str_replace(" ", "", $combinedOrigins); // replace any spaces with nothing

unraid-ui/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unraid/ui",
-  "version": "4.9.0",
+  "version": "4.9.3",
   "private": true,
   "license": "GPL-2.0-or-later",
   "type": "module",

web/__test__/components/HeaderOsVersion.test.ts

@@ -38,6 +38,11 @@ vi.mock('@vue/apollo-composable', () => ({
     onResult: vi.fn(),
     onError: vi.fn(),
   }),
+  useMutation: () => ({
+    mutate: vi.fn(),
+    onDone: vi.fn(),
+    onError: vi.fn(),
+  }),
   provideApolloClient: vi.fn(),
 }));
 

web/__test__/components/Registration.test.ts

@@ -41,6 +41,11 @@ vi.mock('@vue/apollo-composable', () => ({
     onResult: vi.fn(),
     onError: vi.fn(),
   }),
+  useMutation: () => ({
+    mutate: vi.fn(),
+    onDone: vi.fn(),
+    onError: vi.fn(),
+  }),
   provideApolloClient: vi.fn(),
 }));
 

web/components/HeaderOsVersion.ce.vue

@@ -78,7 +78,7 @@ const updateOsStatus = computed(() => {
 </script>
 
 <template>
-  <div class="flex flex-col gap-y-2 mt-2">
+  <div class="flex flex-col gap-y-2 mt-6">
     <a
       :href="unraidLogoHeaderLink.href"
       :title="unraidLogoHeaderLink.title"

web/components/Notifications/Indicator.vue

@@ -1,5 +1,6 @@
 <script setup lang="ts">
-import { computed, type Component } from 'vue';
+import { computed } from 'vue';
+import type { Component } from 'vue';
 import { BellIcon, ExclamationTriangleIcon, ShieldExclamationIcon } from '@heroicons/vue/24/solid';
 import { cn } from '@unraid/ui';
 

web/components/Notifications/Item.vue

@@ -1,5 +1,6 @@
 <script setup lang="ts">
-import { computed, reactive, type Component } from 'vue';
+import { computed, reactive } from 'vue';
+import type { Component } from 'vue';
 import { computedAsync } from '@vueuse/core';
 import { Markdown } from '@/helpers/markdown';
 import {

web/components/UserProfile.ce.vue

@@ -100,7 +100,7 @@ onMounted(() => {
 <template>
   <div
     id="UserProfile"
-    class="text-foreground relative z-20 flex flex-col h-full gap-y-1 mt-2 mr-2"
+    class="text-foreground relative z-20 flex flex-col h-full gap-y-1 pt-2 pr-2"
   >
     <div
       v-if="bannerGradient"

web/helpers/apollo-cache/index.ts

@@ -1,4 +1,5 @@
-import { InMemoryCache, type InMemoryCacheConfig } from '@apollo/client/core';
+import { InMemoryCache } from '@apollo/client/core';
+import type { InMemoryCacheConfig } from '@apollo/client/core';
 
 import type { NotificationOverview } from '~/composables/gql/graphql';
 

web/helpers/markdown.ts

@@ -1,5 +1,6 @@
 import DOMPurify from 'isomorphic-dompurify';
-import { Marked, type MarkedExtension } from 'marked';
+import { Marked } from 'marked';
+import type { MarkedExtension } from 'marked';
 
 const defaultMarkedExtension: MarkedExtension = {
   hooks: {

web/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unraid/web",
-  "version": "4.9.0",
+  "version": "4.9.3",
   "private": true,
   "license": "GPL-2.0-or-later",
   "scripts": {

web/store/account.ts

@@ -61,6 +61,59 @@ export const useAccountStore = defineStore('account', () => {
       accountActionStatus.value = 'waiting';
     }
   };
+
+  // Initialize mutations during store setup to maintain Apollo context
+  const { mutate: signOutMutation, onDone: onSignOutDone, onError: onSignOutError } = useMutation(CONNECT_SIGN_OUT);
+  const { mutate: signInMutation, onDone: onSignInDone, onError: onSignInError } = useMutation(CONNECT_SIGN_IN);
+
+  // Handle sign out mutation results
+  onSignOutDone((res) => {
+    console.debug('[connectSignOutMutation]', res);
+    accountActionStatus.value = 'success';
+    setQueueConnectSignOut(false); // reset
+  });
+
+  onSignOutError((error) => {
+    logErrorMessages(error);
+    accountActionStatus.value = 'failed';
+    errorsStore.setError({
+      heading: 'Failed to update Connect account configuration',
+      message: error.message,
+      level: 'error',
+      ref: 'connectSignOutMutation',
+      type: 'account',
+    });
+  });
+
+  // Handle sign in mutation results
+  onSignInDone((res) => {
+    if (res.data?.connectSignIn) {
+      accountActionStatus.value = 'success';
+      setConnectSignInPayload(undefined); // reset
+      return;
+    }
+    accountActionStatus.value = 'failed';
+    errorsStore.setError({
+      heading: 'unraid-api failed to update Connect account configuration',
+      message: 'Sign In mutation unsuccessful',
+      level: 'error',
+      ref: 'connectSignInMutation',
+      type: 'account',
+    });
+  });
+
+  onSignInError((error) => {
+    logErrorMessages(error);
+    accountActionStatus.value = 'failed';
+    errorsStore.setError({
+      heading: 'unraid-api failed to update Connect account configuration',
+      message: error.message,
+      level: 'error',
+      ref: 'connectSignInMutation',
+      type: 'account',
+    });
+  });
+
   watchEffect(() => {
     if (unraidApiClient.value && connectSignInPayload.value) {
       // connectSignInMutation();
@@ -258,7 +311,7 @@ export const useAccountStore = defineStore('account', () => {
     );
   };
 
-  const connectSignInMutation = async () => {
+  const connectSignInMutation = () => {
     if (
       !connectSignInPayload.value ||
       (connectSignInPayload.value &&
@@ -271,83 +324,21 @@ export const useAccountStore = defineStore('account', () => {
     }
 
     accountActionStatus.value = 'updating';
-    const {
-      mutate: signInMutation,
-      onDone,
-      onError,
-    } = await useMutation(CONNECT_SIGN_IN, {
-      variables: {
-        input: {
-          apiKey: connectSignInPayload.value.apiKey,
-          userInfo: {
-            email: connectSignInPayload.value.email,
-            preferred_username: connectSignInPayload.value.preferred_username,
-          },
+    
+    return signInMutation({
+      input: {
+        apiKey: connectSignInPayload.value.apiKey,
+        userInfo: {
+          email: connectSignInPayload.value.email,
+          preferred_username: connectSignInPayload.value.preferred_username,
         },
       },
     });
-
-    signInMutation();
-
-    onDone((res) => {
-      if (res.data?.connectSignIn) {
-        accountActionStatus.value = 'success';
-        setConnectSignInPayload(undefined); // reset
-        return;
-      }
-      accountActionStatus.value = 'failed';
-      errorsStore.setError({
-        heading: 'unraid-api failed to update Connect account configuration',
-        message: 'Sign In mutation unsuccessful',
-        level: 'error',
-        ref: 'connectSignInMutation',
-        type: 'account',
-      });
-    });
-
-    onError((error) => {
-      logErrorMessages(error);
-      accountActionStatus.value = 'failed';
-      errorsStore.setError({
-        heading: 'unraid-api failed to update Connect account configuration',
-        message: error.message,
-        level: 'error',
-        ref: 'connectSignInMutation',
-        type: 'account',
-      });
-    });
   };
 
-  const connectSignOutMutation = async () => {
+  const connectSignOutMutation = () => {
     accountActionStatus.value = 'updating';
-    // @todo is this still needed here with the change to a mutation?
-    // if (!serverStore.registered && accountAction.value && !accountAction.value?.user) {
-    //   accountActionHide.value = true;
-    //   accountActionStatus.value = 'success';
-    //   return;
-    // }
-
-    const { mutate: signOutMutation, onDone, onError } = await useMutation(CONNECT_SIGN_OUT);
-
-    signOutMutation();
-
-    onDone((res) => {
-      console.debug('[connectSignOutMutation]', res);
-      accountActionStatus.value = 'success';
-      setQueueConnectSignOut(false); // reset
-    });
-
-    onError((error) => {
-      logErrorMessages(error);
-      accountActionStatus.value = 'failed';
-      errorsStore.setError({
-        heading: 'Failed to update Connect account configuration',
-        message: error.message,
-        level: 'error',
-        ref: 'connectSignOutMutation',
-        type: 'account',
-      });
-    });
+    return signOutMutation();
   };
 
   const setAccountAction = (action: ExternalSignIn | ExternalSignOut) => {