Not ready: auto login draft implementation

Signed-off-by: Valentin Sirakov <valentin.sirakov@limechain.tech>

Author: Valentin Sirakov

front-end/src/main/modules/ipcHandlers/localUser/organizationCredentials.ts

@@ -6,6 +6,7 @@ import {
   updateOrganizationCredentials,
   deleteOrganizationCredentials,
   tryAutoSignIn,
+  tryAutoSignInOrganization,
 } from '@main/services/localUser';
 import { createIPCChannel, renameFunc } from '@main/utils/electronInfra';
 
@@ -19,5 +20,6 @@ export default () => {
     renameFunc(updateOrganizationCredentials, 'updateOrganizationCredentials'),
     renameFunc(deleteOrganizationCredentials, 'deleteOrganizationCredentials'),
     renameFunc(tryAutoSignIn, 'tryAutoSignIn'),
+    renameFunc(tryAutoSignInOrganization, 'tryAutoSignInOrganization'),
   ]);
 };

front-end/src/main/services/localUser/organizationCredentials.ts

@@ -274,6 +274,65 @@ export const tryAutoSignIn = async (user_id: string, decryptPassword: string | n
   return failedLogins;
 };
 
+/* Tries to auto sign in to a single organization */
+export const tryAutoSignInOrganization = async (
+  user_id: string,
+  organization_id: string,
+  decryptPassword: string | null,
+): Promise<{ success: boolean; error?: string }> => {
+  const prisma = getPrismaClient();
+
+  try {
+    // Find credentials for this organization
+    const credentials = await prisma.organizationCredentials.findFirst({
+      where: { user_id, organization_id },
+      include: {
+        organization: true,
+      },
+    });
+
+    if (!credentials) {
+      return { success: false, error: 'No credentials found for this organization' };
+    }
+
+    // Check if JWT is already valid (no need to login)
+    const isInvalid = await organizationCredentialsInvalid(credentials);
+    if (!isInvalid) {
+      return { success: true }; // Already logged in
+    }
+
+    // Decrypt the stored password
+    let password: string;
+    try {
+      password = await decryptData(credentials.password, decryptPassword);
+    } catch {
+      return { success: false, error: 'Incorrect decryption password' };
+    }
+
+    // Login to the organization server
+    try {
+      const { accessToken } = await login(
+        credentials.organization.serverUrl,
+        credentials.email,
+        password,
+      );
+
+      // Save the new JWT token to database
+      await prisma.organizationCredentials.update({
+        where: { id: credentials.id },
+        data: { jwtToken: accessToken },
+      });
+
+      return { success: true };
+    } catch (error) {
+      return { success: false, error: error instanceof Error ? error.message : 'Login failed' };
+    }
+  } catch (error) {
+    console.error('Auto-sign in failed:', error);
+    return { success: false, error: error instanceof Error ? error.message : 'Unknown error' };
+  }
+};
+
 /* Encrypt data */
 async function encryptData(data: string, encryptPassword?: string | null) {
   const useKeychain = await getUseKeychainClaim();

front-end/src/preload/localUser/organizationCredentials.ts

@@ -62,5 +62,16 @@ export default {
       ),
     tryAutoSignIn: (user_id: string, decryptPassword: string | null): Promise<Organization[]> =>
       ipcRenderer.invoke('organizationCredentials:tryAutoSignIn', user_id, decryptPassword),
+    tryAutoSignInOrganization: (
+      user_id: string,
+      organization_id: string,
+      decryptPassword: string | null,
+    ): Promise<{ success: boolean; error?: string }> =>
+      ipcRenderer.invoke(
+        'organizationCredentials:tryAutoSignInOrganization',
+        user_id,
+        organization_id,
+        decryptPassword,
+      ),
   },
 };

front-end/src/renderer/components/Organization/ConnectionToggle.vue

@@ -11,6 +11,7 @@ import { useToast } from 'vue-toast-notification';
 import { errorToastOptions } from '@renderer/utils/toastOptions';
 
 import AppSwitch from '@renderer/components/ui/AppSwitch.vue';
+import { useRouter } from 'vue-router';
 
 /* Props */
 const props = defineProps<{
@@ -28,6 +29,7 @@ const emit = defineEmits<{
 /* Stores */
 const orgConnection = useOrganizationConnection();
 const toast = useToast();
+const router = useRouter(); 
 
 /* State */
 const isProcessing = ref(false);
@@ -39,7 +41,16 @@ const isConnected = computed(() => {
 });
 
 const isDisabled = computed(() => {
-  return props.disabled || isProcessing.value;
+  if (props.disabled || isProcessing.value) {
+    return true;
+  }
+  
+  const disconnectReason = orgConnection.getDisconnectReason(props.organization.serverUrl);
+  if (disconnectReason === 'upgradeRequired') {
+    return true;
+  }
+  
+  return false;
 });
 
 /* Handlers */
@@ -68,11 +79,14 @@ const handleToggle = async (checked: boolean) => {
 const handleReconnect = async () => {
   const result = await reconnectOrganization(props.organization.serverUrl);
 
+  if (result.redirectToLogin) {
+    await router.push({ name: 'organizationLogin' });
+    return;
+  }
+
   if (result.success) {
     emit('connect');
   } else if (result.requiresUpdate) {
-    // Version check failed - modal will be shown by reconnect service
-    // Don't emit error, just let the user know via the modal
     console.log('Reconnection requires update - modal should be shown');
   } else {
     throw new Error('Failed to reconnect');

front-end/src/renderer/pages/OrganizationLogin/OrganizationLogin.vue

@@ -90,17 +90,30 @@ const handleLogin = async () => {
     );
     await user.refetchOrganizationTokens();
     await performVersionCheck(user.selectedOrganization.serverUrl);
-
+    await user.refetchOrganizations();
+    
     toast.success('Successfully signed in', successToastOptions);
 
     loading.value = false;
 
-    await withLoader(
-      user.selectOrganization.bind(null, user.selectedOrganization),
-      'Failed to change user mode',
-      10000,
-      false,
-    );
+    // Small delay to ensure database write is committed
+    await new Promise(resolve => setTimeout(resolve, 50));
+
+    const updatedOrg = user.organizations.find(org => org.id === user.selectedOrganization?.id);
+    if (!updatedOrg) {
+      throw new Error('Organization not found after refresh');
+    }
+
+    if ('loginRequired' in updatedOrg && !updatedOrg.loginRequired) {
+      await withLoader(
+        user.selectOrganization.bind(null, updatedOrg),
+        'Failed to change user mode',
+        10000,
+        false,
+      );
+    } else {
+      await user.selectOrganization(updatedOrg);
+    }
 
     if (isOrganizationActive(user.selectedOrganization)) {
       await setLast(user.selectedOrganization.id);

front-end/src/renderer/services/organization/disconnect.ts

@@ -7,6 +7,7 @@ import useOrganizationConnection from '@renderer/stores/storeOrganizationConnect
 import { toggleAuthTokenInSessionStorage } from '@renderer/utils';
 import { useToast } from 'vue-toast-notification';
 import { errorToastOptions, infoToastOptions } from '@renderer/utils/toastOptions';
+import { updateOrganizationCredentials } from '../organizationCredentials';
 
 export async function disconnectOrganization(
   serverUrl: string,
@@ -24,6 +25,15 @@ export async function disconnectOrganization(
   toggleAuthTokenInSessionStorage(serverUrl, '', true);
 
   const org = userStore.organizations.find(o => o.serverUrl === serverUrl);
+  if (org && userStore.personal && userStore.personal.isLoggedIn) {
+    try {
+      await updateOrganizationCredentials(org.id, userStore.personal.id, undefined, undefined, null);
+      await userStore.refetchOrganizationTokens();
+    } catch (error) {
+      console.error('Failed to remove JWT from SQLite:', error);
+    }
+  }
+
   if (org) {
     org.connectionStatus = 'disconnected';
     org.disconnectReason = reason;

front-end/src/renderer/services/organization/reconnect.ts

@@ -19,6 +19,8 @@ import useVersionCheck from '@renderer/composables/useVersionCheck';
 
 import { useToast } from 'vue-toast-notification';
 import { errorToastOptions } from '@renderer/utils/toastOptions';
+import usePersonalPassword from '@renderer/composables/usePersonalPassword';
+import { tryAutoSignInOrganization } from '@renderer/services/organizationCredentials';
 
 /**
  * Reconnect an organization with version checking and compatibility validation.
@@ -35,6 +37,7 @@ export async function reconnectOrganization(serverUrl: string): Promise<{
   success: boolean;
   requiresUpdate?: boolean;
   hasCompatibilityConflict?: boolean;
+  redirectToLogin?: boolean;
 }> {
   const userStore = useUserStore();
   const ws = useWebsocketConnection();
@@ -49,6 +52,66 @@ export async function reconnectOrganization(serverUrl: string): Promise<{
     return { success: false };
   }
 
+    if (
+      !org.isLoading &&
+      org.isServerActive &&
+      'loginRequired' in org &&
+      org.loginRequired &&
+      userStore.personal &&
+      userStore.personal.isLoggedIn
+    ) {
+      const personalId = userStore.personal.id;
+      const organizationId = org.id;
+      
+      const { getPasswordV2 } = usePersonalPassword();
+      
+      const autoLoginResult = await new Promise<{ success: boolean; noCredentials?: boolean }>((resolve) => {
+        getPasswordV2(
+          async (password: string | null) => {
+            try {
+              const result = await tryAutoSignInOrganization(
+                personalId,
+                organizationId,
+                password,
+              );
+  
+              if (!result.success) {
+                if (result.error?.includes('No credentials found')) {
+                  resolve({ success: false, noCredentials: true });
+                  return;
+                }
+                
+                console.error('Auto-login failed:', result.error);
+                resolve({ success: false });
+                return;
+              }
+  
+              await userStore.refetchOrganizationTokens();
+              resolve({ success: true });
+            } catch (error) {
+              console.error('Auto-login error:', error);
+              resolve({ success: false });
+            }
+          },
+          {
+            heading: 'Enter your application password',
+            subHeading: 'To decrypt organization credentials and reconnect',
+          },
+        );
+      });
+  
+      if (autoLoginResult.noCredentials) {
+        console.log(`No credentials found for ${org.nickname || serverUrl}`);
+        userStore.selectedOrganization = org;
+        return { success: false, redirectToLogin: true };
+      }
+  
+      if (!autoLoginResult.success) {
+        return { success: false };
+      }
+    }
+  
+
   try {
     console.log(
       `[${new Date().toISOString()}] RECONNECT Starting version check for: ${org.nickname || serverUrl}`,

front-end/src/renderer/services/organizationCredentials.ts

@@ -82,3 +82,17 @@ export const tryAutoSignIn = async (user_id: string, decryptPassword: string | n
       decryptPassword,
     );
   }, 'Failed failed to auto sign in to organizations');
+
+/* Try auto sign in to a single organization */
+export const tryAutoSignInOrganization = async (
+  user_id: string,
+  organization_id: string,
+  decryptPassword: string | null,
+) =>
+  commonIPCHandler(async () => {
+    return await window.electronAPI.local.organizationCredentials.tryAutoSignInOrganization(
+      user_id,
+      organization_id,
+      decryptPassword,
+    );
+  }, 'Failed to auto sign in to organization');

front-end/src/renderer/stores/storeUser.ts

@@ -229,6 +229,40 @@ const useUserStore = defineStore('user', () => {
           return;
         }
       }
+
+      const connectedOrg = await ush.getConnectedOrganization(organization, personal.value);
+
+      if (
+        connectedOrg &&
+        !connectedOrg.isLoading &&
+        connectedOrg.isServerActive &&
+        'loginRequired' in connectedOrg &&
+        connectedOrg.loginRequired &&
+        personal.value &&
+        personal.value.isLoggedIn
+      ) {
+        const orgServerUrl = connectedOrg.serverUrl;
+        
+        const { reconnectOrganization } = await import('@renderer/services/organization/reconnect');
+        const result = await reconnectOrganization(orgServerUrl);
+        
+        if (result.redirectToLogin) {
+          selectedOrganization.value = connectedOrg;
+          await afterOrganizationSelection();
+          return;
+        }
+        
+        if (result.success) {
+          await refetchOrganizations();
+          selectedOrganization.value = await ush.getConnectedOrganization(organization, personal.value);
+          await afterOrganizationSelection();
+          return;
+        } else {
+          selectedOrganization.value = connectedOrg;
+          await afterOrganizationSelection();
+          return;
+        }
+      }
     }
 
     // Check if currently selected organization becomes disconnected
@@ -260,8 +294,8 @@ const useUserStore = defineStore('user', () => {
   };
 
   const refetchOrganizations = async () => {
-    await ush.updateConnectedOrganizations(organizations, personal.value);
     await refetchOrganizationTokens();
+    await ush.updateConnectedOrganizations(organizations, personal.value);
   };
 
   const deleteOrganization = async (organizationId: string) => {