feat: handle mandatory update refusal by disconnecting from organization only not quitting app

back-end/apps/api/src/guards/frontend-version.guard.spec.ts

@@ -71,8 +71,7 @@ describe('FrontendVersionGuard', () => {
         expect(error).toBeInstanceOf(HttpException);
         expect((error as HttpException).getStatus()).toBe(426);
         const response = (error as HttpException).getResponse() as Record<string, unknown>;
-        expect(response.minimumVersion).toBe('1.0.0');
-        expect(response.currentVersion).toBe('0.9.0');
+        expect(response.minimumSupportedVersion).toBe('1.0.0');
       }
     });
 
@@ -487,4 +486,3 @@ describe('FrontendVersionGuard', () => {
     });
   });
 });
-

back-end/apps/api/src/guards/frontend-version.guard.ts

@@ -37,6 +37,7 @@ export class FrontendVersionGuard implements CanActivate {
     const request = context.switchToHttp().getRequest();
     const frontendVersion = request.headers['x-frontend-version'];
     const minimumVersion = this.configService.get<string>('MINIMUM_SUPPORTED_FRONTEND_VERSION');
+    const latestVersion = this.configService.get<string>('LATEST_SUPPORTED_FRONTEND_VERSION');
     const clientIp = request.headers['x-forwarded-for'] || request.ip || 'unknown';
 
     const UPGRADE_REQUIRED = 426;
@@ -95,8 +96,8 @@ export class FrontendVersionGuard implements CanActivate {
           statusCode: UPGRADE_REQUIRED,
           message: `Your application version (${cleanFrontendVersion}) is no longer supported. Minimum required version is ${cleanMinimumVersion}. Please update your application.`,
           error: 'Upgrade Required',
-          minimumVersion: cleanMinimumVersion,
-          currentVersion: cleanFrontendVersion,
+          minimumSupportedVersion: cleanMinimumVersion,
+          latestSupportedVersion: latestVersion,
           updateUrl,
         },
         UPGRADE_REQUIRED,

front-end/package.json

@@ -48,6 +48,7 @@
     "msgpackr": "1.11.5",
     "node-forge": "1.3.1",
     "pinia": "2.3.1",
+    "semver": "7.7.1",
     "socket.io-client": "4.8.1",
     "unzipper": "0.12.3",
     "vue-router": "4.5.0",
@@ -62,6 +63,7 @@
     "@types/bootstrap": "5.2.10",
     "@types/node": "22.12.0",
     "@types/node-forge": "1.3.11",
+    "@types/semver": "7.5.8",
     "@types/unzipper": "0.10.10",
     "@vitejs/plugin-vue": "5.2.1",
     "@vitest/coverage-v8": "3.0.5",

front-end/src/renderer/components/GlobalAppProcesses/GlobalAppProcesses.vue

@@ -10,10 +10,16 @@ import useLoader from '@renderer/composables/useLoader';
 import useSetupStores from '@renderer/composables/user/useSetupStores';
 import useRecoveryPhraseHashMigrate from '@renderer/composables/useRecoveryPhraseHashMigrate';
 import useDefaultOrganization from '@renderer/composables/user/useDefaultOrganization';
+import useVersionCheck from '@renderer/composables/useVersionCheck';
 
 import { getUseKeychain } from '@renderer/services/safeStorageService';
 import { getUsersCount, resetDataLocal } from '@renderer/services/userService';
 import { getStoredClaim } from '@renderer/services/claimService';
+import { checkCompatibilityAcrossOrganizations } from '@renderer/services/organization/versionCompatibility';
+import {
+  getVersionStatusForOrg,
+  organizationCompatibilityResults,
+} from '@renderer/stores/versionState';
 
 import AutoLoginInOrganization from '@renderer/components/Organization/AutoLoginInOrganization.vue';
 import AppUpdate from './components/AppUpdate.vue';
@@ -31,6 +37,7 @@ const tryAutoLogin = useAutoLogin();
 const setupStores = useSetupStores();
 const { select: selectDefaultOrganization } = useDefaultOrganization();
 const { redirectIfRequiredKeysToMigrate } = useRecoveryPhraseHashMigrate();
+const { performVersionCheck, getAllOrganizationVersionData } = useVersionCheck();
 
 /* State */
 const importantNoteRef = ref<InstanceType<typeof ImportantNote> | null>(null);
@@ -56,8 +63,83 @@ const handleBeginMigrationReadyState = async () => {
   }
 
   await setupStores();
+
+  if (user.personal?.isLoggedIn && user.organizations.length > 0) {
+    await checkAllOrganizationVersions();
+  }
 };
 
+async function checkAllOrganizationVersions(): Promise<void> {
+  try {
+    const versionChecks = user.organizations.map(org => performVersionCheck(org.serverUrl));
+    await Promise.allSettled(versionChecks);
+
+    const orgsRequiringUpdate = user.organizations.filter(org => {
+      const status = getVersionStatusForOrg(org.serverUrl);
+      return status === 'updateAvailable' || status === 'belowMinimum';
+    });
+
+    if (orgsRequiringUpdate.length > 0) {
+      await checkCompatibilityForUpgrades(orgsRequiringUpdate);
+    }
+  } catch (error) {
+    console.error('Failed to check organization versions on launch:', error);
+  }
+}
+
+async function checkCompatibilityForUpgrades(
+  orgsRequiringUpdate: typeof user.organizations,
+): Promise<void> {
+  const allVersionData = getAllOrganizationVersionData();
+
+  for (const org of orgsRequiringUpdate) {
+    const versionData = allVersionData[org.serverUrl];
+    if (!versionData || !versionData.latestSupportedVersion) {
+      continue;
+    }
+
+    try {
+      const compatibilityResult = await checkCompatibilityAcrossOrganizations(
+        versionData.latestSupportedVersion,
+        org.serverUrl, // Exclude the current org from conflict check
+      );
+
+      organizationCompatibilityResults.value[org.serverUrl] = compatibilityResult;
+
+      if (compatibilityResult.hasConflict) {
+        console.warn(
+          `[${new Date().toISOString()}] COMPATIBILITY_CHECK App launch check for ${org.serverUrl}`,
+        );
+        console.warn(
+          `Conflicts found with ${compatibilityResult.conflicts.length} organization(s):`,
+        );
+        compatibilityResult.conflicts.forEach(conflict => {
+          console.warn(
+            `  - ${conflict.organizationName} (${conflict.serverUrl}): Latest supported: ${conflict.latestSupportedVersion}`,
+          );
+        });
+      } else {
+        console.log(
+          `[${new Date().toISOString()}] COMPATIBILITY_CHECK App launch check for ${org.serverUrl}: No conflicts`,
+        );
+      }
+    } catch (error) {
+      console.error(`Failed to check compatibility for ${org.serverUrl}:`, error);
+      organizationCompatibilityResults.value[org.serverUrl] = null;
+    }
+  }
+
+  if (orgsRequiringUpdate.length > 1) {
+    console.log(
+      `[${new Date().toISOString()}] MULTIPLE_ORGS_REQUIRING_UPDATE: ${orgsRequiringUpdate.length} organization(s) require updates`,
+    );
+    orgsRequiringUpdate.forEach(org => {
+      const status = getVersionStatusForOrg(org.serverUrl);
+      console.log(`  - ${org.nickname || org.serverUrl}: ${status}`);
+    });
+  }
+}
+
 /* Hooks */
 onMounted(async () => {
   try {