@kumori/aurora-backend-handler 1.0.99 → 1.0.111

package/websocket-manager.ts

@@ -1,13 +1,14 @@
 import { v7 as uuidv7 } from "uuid";
 import { environment } from "./environment";
+import { AccountStatus } from "@kumori/aurora-interfaces/enums/accountStatusEnum";
 import {
   Account,
   Channel,
   ClusterToken,
   Environment,
+  errors,
   Instance,
-  Link,
-  MarketplaceService,
+  MarketplaceItem,
   Notification,
   Organization,
   Plan,
@@ -17,11 +18,10 @@ import {
   Resource,
   Service,
   Tenant,
-  tenantRole,
   Token,
-  Usage,
   User,
   UserData,
+  UserStatus
 } from "@kumori/aurora-interfaces";
 import { loadMarketplaceItemsForTenant } from "./api/marketplace-api-service";
 import { getReporting } from "./api/reporting-api-service";
@@ -31,8 +31,8 @@ import {
   handleTenantOperationSuccess,
 } from "./helpers/tenant-helper";
 import {
+  handleUserDelete,
   handleUserEvent,
-  handleUserOperationError,
 } from "./helpers/user-helper";
 import {
   handleEnvironmentEvent,
@@ -63,6 +63,7 @@ import {
   handleSecretEvent,
   handleVolumeEvent,
   processResourceResult,
+  setResourceDeleting,
 } from "./helpers/resource-helper";
 import {
   handlePlanInstanceEvent,
@@ -70,6 +71,7 @@ import {
 } from "./helpers/plan-helper";
 import { handleRegistryEvent } from "./helpers/registry-helper";
 import {
+  handleTokenDeletion,
   handleTokenEvent,
   handleTokenOperationSuccess,
 } from "./helpers/token-helper";
@@ -77,6 +79,7 @@ import { handleLinkEvent } from "./helpers/link-helper";
 import { eventHelper } from "./backend-handler";
 import { Revision } from "@kumori/aurora-interfaces/interfaces/revision-interface";
 import { requestRevisionData } from "./api/service-api-service";
+import { processMarketplaceSchemaResponse } from "./helpers/marketplace-helper";
 
 let WebSocketClass: any;
 
@@ -145,10 +148,12 @@ interface Role {
  */
 let wsConnection: WebSocket | null = null;
 let pendingRequests = new Map<string, PendingOperation>();
+let purgingEnvironments = new Set<string>();
 let currentToken: string | null = null;
 let connectionPromise: Promise<WebSocket> | null = null;
 let userData: UserData = {
   id: "",
+  created: "",
   name: "",
   surname: "",
   provider: [],
@@ -171,6 +176,7 @@ let accountsMap = new Map<string, Account>();
 let revisionsMap = new Map<string, Revision>();
 let roleMap = new Map<string, Role[]>();
 let tokenMap = new Map<string, Token>();
+let deletedTokenIds = new Set<string>();
 let platformInfo: Platform | null = null;
 let isPlatformInfoLoading = false;
 let isPlatformInfoLoaded = false;
@@ -192,6 +198,19 @@ const REPORTING_ITERATIONS = 5;
 const REPORTING_INTERVAL = 1000;
 let hasLoadedReportingOnce = false;
 let recentlyUpdatedServices = new Map<string, Service>();
+let pendingTenantStatus = new Map<string, string>();
+let reconnectAttempts = 0;
+let reconnectTimer: ReturnType<typeof setTimeout> | null = null;
+let isManualClose = false;
+let lastConnectionParams: {
+  token: string;
+  type?: string;
+  name?: string;
+  previousData?: UserData;
+} | null = null;
+const MAX_RECONNECT_ATTEMPTS = 5;
+const RECONNECT_BASE_DELAY = 1000;
+const RECONNECT_MAX_DELAY = 30000;
 /**
  * Helper function to safely stringify error objects
  */
@@ -234,6 +253,7 @@ export const initializeGlobalWebSocketClient = async (
 ): Promise<WebSocket> => {
   userData.notifications = previousData?.notifications;
   globalEntityName = name || null;
+  lastConnectionParams = { token, type, name, previousData };
   if (
     wsConnection &&
     wsConnection.readyState === WebSocket.OPEN &&
@@ -265,8 +285,9 @@ export const initializeGlobalWebSocketClient = async (
       if (typeof window === "undefined") {
         wsConnection = new WebSocketClass(wsUrl, {
           headers: {
-            authorization: `Bearer ${token}`,
+            // authorization: `Bearer ${token}`,
           },
+          credentials: "include",
         });
       } else {
         wsConnection = new WebSocketClass(wsUrl);
@@ -275,6 +296,11 @@ export const initializeGlobalWebSocketClient = async (
       wsConnection?.addEventListener("open", async () => {
         currentToken = token;
         connectionPromise = null;
+        reconnectAttempts = 0;
+        if (reconnectTimer) {
+          clearTimeout(reconnectTimer);
+          reconnectTimer = null;
+        }
 
         resolve(wsConnection!);
       });
@@ -346,7 +372,7 @@ export const initializeGlobalWebSocketClient = async (
             message.error?.code === "_unknown_user_" &&
             message.error?.content !== "Unknown proposed user."
           ) {
-            userData.status = "unknown";
+            userData.status = UserStatus.UNKNOWN;
             user = new User(userData);
             eventHelper.user.publish.loaded(user);
           }
@@ -368,13 +394,17 @@ export const initializeGlobalWebSocketClient = async (
           pending.reject(new Error("WebSocket connection closed"));
           pendingRequests.delete(messageId);
         });
+
+        if (isManualClose) {
+          isManualClose = false;
+          return;
+        }
+
+        scheduleReconnect();
       });
 
       wsConnection?.addEventListener("error", (error) => {
         console.error("Global WebSocket error:", error);
-        userData.status = "notlogged";
-        user = new User(userData);
-        eventHelper.user.publish.loaded(user);
         connectionPromise = null;
         reject(error);
       });
@@ -387,6 +417,38 @@ export const initializeGlobalWebSocketClient = async (
   return connectionPromise;
 };
 
+/**
+ * Schedule a reconnection attempt after an unexpected connection drop
+ * (e.g. a transient network blip while the tab was backgrounded).
+ * Uses exponential backoff and gives up after MAX_RECONNECT_ATTEMPTS.
+ */
+const scheduleReconnect = () => {
+  if (reconnectTimer || !lastConnectionParams) {
+    return;
+  }
+
+  if (reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) {
+    console.error("WebSocket reconnection attempts exhausted");
+    return;
+  }
+
+  const delay = Math.min(
+    RECONNECT_BASE_DELAY * Math.pow(2, reconnectAttempts),
+    RECONNECT_MAX_DELAY,
+  );
+  reconnectAttempts++;
+
+  reconnectTimer = setTimeout(() => {
+    reconnectTimer = null;
+    const { token, type, name, previousData } = lastConnectionParams!;
+    initializeGlobalWebSocketClient(token, type, name, previousData).catch(
+      (error) => {
+        console.error("WebSocket reconnect attempt failed:", error);
+      },
+    );
+  }, delay);
+};
+
 /**
  * Function to make WebSocket requests using the global connection
  * @param topic Request topic (group:method)
@@ -426,6 +488,14 @@ export const makeGlobalWebSocketRequest = async (
     payload,
   };
 
+  let purgeEnvKey: string | null = null;
+  if (petitionAction === "CLEAN" && entityType === "environment" && originalData) {
+    purgeEnvKey = originalData.tenant && originalData.account
+      ? `${originalData.tenant}/${originalData.account}/${petitionInfo}`
+      : petitionInfo;
+    purgingEnvironments.add(purgeEnvKey);
+  }
+
   return new Promise((resolve, reject) => {
     const timeoutId = setTimeout(() => {
       const pending = pendingRequests.get(messageId);
@@ -441,16 +511,23 @@ export const makeGlobalWebSocketRequest = async (
           new Error(`Request timeout for ${topic}`),
         );
       }
-      reject(new Error(`Request timeout for ${topic}`));
+      if (purgeEnvKey) purgingEnvironments.delete(purgeEnvKey);
+      const timeoutError = Object.assign(
+        new Error(`Request timeout for ${topic}`),
+        { isTimeout: true },
+      );
+      reject(timeoutError);
     }, timeout);
 
     const operation: PendingOperation = {
       resolve: (response: any) => {
         clearTimeout(timeoutId);
+        if (purgeEnvKey) purgingEnvironments.delete(purgeEnvKey);
         resolve(response.payload || response);
       },
       reject: (error: any) => {
         clearTimeout(timeoutId);
+        if (purgeEnvKey) purgingEnvironments.delete(purgeEnvKey);
         const errorMessage = safeStringifyError(error);
         console.error(`WebSocket request failed for ${topic}:`, {
           originalError: error,
@@ -527,6 +604,23 @@ export const makeGlobalWebSocketRequestWithRetry = async (
   );
 };
 
+export const markEnvironmentAsPurging = (envKey: string) => {
+  purgingEnvironments.add(envKey);
+  const env = environmentsMap.get(envKey);
+  if (env) {
+    const updatedEnv: Environment = {
+      ...env,
+      status: {
+        code: "PURGING",
+        message: `Environment ${env.name} is being purged.`,
+        timestamp: new Date().toISOString(),
+      },
+    };
+    environmentsMap.set(envKey, updatedEnv);
+    eventHelper.environment.publish.updated(updatedEnv);
+  }
+};
+
 /**
  * Get the current WebSocket connection status
  * @returns Connection status and token info
@@ -545,6 +639,14 @@ export const getWebSocketStatus = () => {
  * Close the global WebSocket connection
  */
 export const closeGlobalWebSocketConnection = () => {
+  isManualClose = true;
+  lastConnectionParams = null;
+  reconnectAttempts = 0;
+  if (reconnectTimer) {
+    clearTimeout(reconnectTimer);
+    reconnectTimer = null;
+  }
+
   if (wsConnection) {
     wsConnection.close();
     wsConnection = null;
@@ -562,13 +664,24 @@ export const closeGlobalWebSocketConnection = () => {
   });
 };
 
+const computePromotionInfo = (
+  tenants: Tenant[],
+): { completedSteps: number; remainingDays: number } => {
+  const hasValidCredentialsAccount = tenants.some((tenant) =>
+    tenant.accounts?.some((account) => account.status === AccountStatus.ACTIVE),
+  );
+  const hasDeployedService = tenants.some((tenant) => tenant.services?.length > 0);
+  const completedSteps = (hasValidCredentialsAccount ? 1 : 0) + (hasDeployedService ? 1 : 0);
+  return { completedSteps, remainingDays: 7 };
+};
+
 const rebuildHierarchy = () => {
   const preservedUserData = { ...userData };
 
   tenantsMap.forEach((tenant) => {
     tenant.accounts = Array.from(accountsMap.values()).filter((account) => {
       account.environments = Array.from(environmentsMap.values())
-        .filter((env) => env.account === account.id)
+        .filter((env) => env.account === account.id && env.tenant === account.tenant)
         .map((env) => env.name);
       return account.tenant === tenant.id;
     });
@@ -594,16 +707,20 @@ const rebuildHierarchy = () => {
       }
     }
   });
-
   userData = {
     id: preservedUserData.id,
+    created: preservedUserData.created,
     name: preservedUserData.name,
     surname: preservedUserData.surname,
     provider: preservedUserData.provider.map((p) => ({ ...p })),
     notificationsEnabled: preservedUserData.notificationsEnabled,
     organizations: Array.from(organizationsMap.values()),
     clusterTokens: Array.from(clusterTokensMap.values()),
-    tokens: preservedUserData.tokens || [],
+    tokens: (
+      tokenMap.size > 0
+        ? (preservedUserData.tokens || []).filter(t => tokenMap.has(t.name))
+        : (preservedUserData.tokens || [])
+    ).filter(t => !deletedTokenIds.has(t.name)),
     tenants: Array.from(tenantsMap.values()),
     axebowPlan: preservedUserData.axebowPlan,
     companyName: preservedUserData.companyName,
@@ -613,6 +730,7 @@ const rebuildHierarchy = () => {
     notifications: preservedUserData.notifications || [],
     plans: preservedUserData.plans || [],
     discoveryMethod: preservedUserData.discoveryMethod,
+    promotionInfo: computePromotionInfo(Array.from(tenantsMap.values())),
   };
 };
 const handleEvent = async (message: WSMessage) => {
@@ -630,6 +748,7 @@ const handleEvent = async (message: WSMessage) => {
       : {};
     switch (kind) {
       case "user":
+        const previousTokens = userData.tokens || [];
         const userEventResult = handleUserEvent({
           eventData,
           tenantsMap,
@@ -639,7 +758,22 @@ const handleEvent = async (message: WSMessage) => {
           parseKeyPath,
           eventHelper,
         });
+        Object.entries(eventData.status.tenants).forEach(
+          ([tenantId, tenantInfo]: [string, any]) => {
+            if (tenantInfo.status === "rejected") {
+              const tenant = tenantsMap.get(tenantId);
+              if (tenant) {
+                tenantsMap.set(tenantId, { ...tenant, status: "leaving" });
+              } else {
+                pendingTenantStatus.set(tenantId, "leaving");
+              }
+            }
+          },
+        );
         userData = userEventResult.userData;
+        if (!userData.tokens?.length && previousTokens.length) {
+          userData.tokens = previousTokens;
+        }
         tempProviders = userEventResult.tempProviders;
         userEventResult.deletedTenantKeys.forEach((key) => {
           tenantsMap.delete(key);
@@ -660,7 +794,19 @@ const handleEvent = async (message: WSMessage) => {
             envEventResult.pendingCloudProviderUpdate,
           );
         }
-        environmentsMap.set(entityId, envEventResult.environment);
+        const envSetKey = parentParts.tenant && parentParts.account ? `${parentParts.tenant}/${parentParts.account}/${entityId}` : entityId;
+        let envToStore = envEventResult.environment;
+        if (envToStore.status?.code?.startsWith("DELETING") && purgingEnvironments.has(envSetKey)) {
+          envToStore = {
+            ...envToStore,
+            status: {
+              code: "PURGING",
+              message: `Environment ${entityId} is being purged.`,
+              timestamp: new Date().toISOString(),
+            },
+          };
+        }
+        environmentsMap.set(envSetKey, envToStore);
         const envTenant = tenantsMap.get(envEventResult.tenantId);
         if (!envTenant) {
           pendingEnvironments.push({
@@ -694,12 +840,16 @@ const handleEvent = async (message: WSMessage) => {
         }
         if (revisionResult.updatedEnvironment) {
           const envId = revisionResult.updatedService?.environment;
-          if (envId)
-            environmentsMap.set(envId, revisionResult.updatedEnvironment);
+          const envRevTenant = revisionResult.updatedEnvironment.tenant;
+          const envRevAccount = revisionResult.updatedEnvironment.account;
+          const envRevKey = envRevTenant && envRevAccount && envId ? `${envRevTenant}/${envRevAccount}/${envId}` : envId;
+          if (envRevKey) environmentsMap.set(envRevKey, revisionResult.updatedEnvironment);
         }
         if (revisionResult.updatedAccount) {
           const accId = revisionResult.updatedService?.account;
-          if (accId) accountsMap.set(accId, revisionResult.updatedAccount);
+          const accRevTenant = revisionResult.updatedAccount.tenant;
+          const accRevKey = accRevTenant && accId ? `${accRevTenant}/${accId}` : accId;
+          if (accRevKey) accountsMap.set(accRevKey, revisionResult.updatedAccount);
         }
         if (revisionResult.pendingRevisionError) {
           pendingRevisionErrors.push(revisionResult.pendingRevisionError);
@@ -792,8 +942,9 @@ const handleEvent = async (message: WSMessage) => {
         });
 
         if (!message.payload.deleted) {
-          accountsMap.set(entityId, accountResult.account);
-          updateEnvironmentsCloudProvider(entityId, eventData.spec.api);
+          const accountKey = parentParts.tenant ? `${parentParts.tenant}/${entityId}` : entityId;
+          accountsMap.set(accountKey, accountResult.account);
+          updateEnvironmentsCloudProvider(entityId, eventData.spec.api, parentParts.tenant);
         }
         break;
 
@@ -804,6 +955,45 @@ const handleEvent = async (message: WSMessage) => {
           eventData,
           userData,
         );
+        if (
+          existingTenant &&
+          existingTenant.role &&
+          newTenant.role &&
+          existingTenant.role !== newTenant.role
+        ) {
+          const roleNotification: Notification = {
+            type: "info",
+            subtype: errors.tenant.roleChanged.subtype,
+            date: Date.now().toString(),
+            status: "unread",
+            callToAction: false,
+            data: {
+              tenant: newTenant.name,
+              oldRole: existingTenant.role,
+              newRole: newTenant.role,
+            },
+          };
+          eventHelper.notification.publish.creation(roleNotification);
+        }
+        existingTenant?.users
+          ?.filter((u) => u.status === "pending" && u.id !== userData.id)
+          .forEach((previousUser) => {
+            const currentUser = newTenant.users?.find((u) => u.id === previousUser.id);
+            if (currentUser?.status === "pending") return;
+            const invitationNotification: Notification = {
+              type: "info",
+              subtype: currentUser ? "tenant-invitation-accepted" : "tenant-invitation-declined",
+              date: Date.now().toString(),
+              status: "unread",
+              callToAction: false,
+              data: {
+                tenant: newTenant.name,
+                user: previousUser.id,
+                role: previousUser.role,
+              },
+            };
+            eventHelper.notification.publish.creation(invitationNotification);
+          });
         if (existingTenant) {
           if (
             !newTenant.resources?.length &&
@@ -829,6 +1019,12 @@ const handleEvent = async (message: WSMessage) => {
         }
 
         tenantsMap.set(entityId, newTenant);
+        if (pendingTenantStatus.has(entityId)) {
+          const pendingStatus = pendingTenantStatus.get(entityId)!;
+          tenantsMap.set(entityId, { ...newTenant, status: pendingStatus });
+          pendingTenantStatus.delete(entityId);
+        }
+
         loadMarketplaceItemsForTenant(entityId, "") //TODO Move to helper
           .then((items) => {
             const tenant = tenantsMap.get(entityId);
@@ -931,13 +1127,17 @@ const handleEvent = async (message: WSMessage) => {
         break;
 
       case "ca":
-        const caResult = handleCAEvent(eventData, parentParts, tenantsMap, hasRequestingServices,);
+        const caResult = handleCAEvent(
+          eventData,
+          parentParts,
+          tenantsMap,
+          hasRequestingServices,
+        );
         processResourceResult(
           caResult,
           tenantsMap,
           pendingDomains,
           eventHelper,
-          
         );
         break;
 
@@ -1030,6 +1230,7 @@ const handleEvent = async (message: WSMessage) => {
           eventData,
           tokenMap,
           userData,
+          deletedTokenIds,
         });
 
         if (tokenResult.isUserToken) {
@@ -1236,6 +1437,7 @@ const handleOperationSuccess = (operation: PendingOperation, response: any) => {
           const channelsInfo = mapChannelsFromApiData(
             response.payload.data,
             serviceName,
+            service.resources, 
           );
           service.serverChannels = channelsInfo.serverChannels;
           service.clientChannels = channelsInfo.clientChannels;
@@ -1252,7 +1454,7 @@ const handleOperationSuccess = (operation: PendingOperation, response: any) => {
           svcSuccessResult.revisionData
         ) {
           try {
-            const updatedService = processRevisionData(
+            let updatedService = processRevisionData(
               svcSuccessResult.updatedService!,
               svcSuccessResult.revisionData,
               revisionsMap,
@@ -1272,6 +1474,28 @@ const handleOperationSuccess = (operation: PendingOperation, response: any) => {
               };
             }
 
+            const resources = updatedService.resources || [];
+            if (resources.length > 0) {
+              const applyIsPublic = (channels: Channel[]): Channel[] =>
+                channels.map((ch) => ({
+                  ...ch,
+                  isPublic:
+                    ch.isPublic ||
+                    resources.some(
+                      (r) =>
+                        (r.type === "port" || r.type === "domain") &&
+                        (r.name === `${ch.name}_port` || r.name === `${ch.name}_domain`),
+                    ),
+                }));
+      
+              updatedService = {
+                ...updatedService,
+                serverChannels: applyIsPublic(updatedService.serverChannels || []),
+                clientChannels: applyIsPublic(updatedService.clientChannels || []),
+                duplexChannels: applyIsPublic(updatedService.duplexChannels || []),
+              };
+            }
+      
             servicesMap.set(svcSuccessResult.serviceId, updatedService);
 
             if (updatedService.role && updatedService.role.length > 0) {
@@ -1326,16 +1550,18 @@ const handleOperationSuccess = (operation: PendingOperation, response: any) => {
         originalData: originalData as Account,
       });
 
+      const accTenant = (originalData as Account)?.tenant;
+      const accSuccessKey = accTenant ? `${accTenant}/${entityName}` : entityName;
       if (accSuccessResult.shouldDelete) {
-        const acc = accountsMap.get(entityName);
+        const acc = accountsMap.get(accSuccessKey);
         if (acc) {
-          accountsMap.delete(entityName);
+          accountsMap.delete(accSuccessKey);
           eventHelper.notification.publish.creation(
             accSuccessResult.notification,
           );
         }
       } else if (accSuccessResult.updatedAccount) {
-        accountsMap.set(entityName, accSuccessResult.updatedAccount);
+        accountsMap.set(accSuccessKey, accSuccessResult.updatedAccount);
         if (accSuccessResult.eventType === "created") {
           eventHelper.account.publish.created(accSuccessResult.updatedAccount);
         } else if (accSuccessResult.eventType === "updated") {
@@ -1354,10 +1580,12 @@ const handleOperationSuccess = (operation: PendingOperation, response: any) => {
         originalData: originalData as Environment,
       });
 
+      const envOrigData = originalData as Environment;
+      const envSuccessKey = envOrigData?.tenant && envOrigData?.account ? `${envOrigData.tenant}/${envOrigData.account}/${entityName}` : entityName;
       if (envSuccessResult.shouldDelete) {
-        environmentsMap.delete(entityName);
+        environmentsMap.delete(envSuccessKey);
       } else if (envSuccessResult.updatedEnvironment) {
-        environmentsMap.set(entityName, envSuccessResult.updatedEnvironment);
+        environmentsMap.set(envSuccessKey, envSuccessResult.updatedEnvironment);
         if (envSuccessResult.notification) {
           eventHelper.notification.publish.creation(
             envSuccessResult.notification,
@@ -1385,15 +1613,44 @@ const handleOperationSuccess = (operation: PendingOperation, response: any) => {
       }
       break;
     case "token":
-      const tokenSuccessResult = handleTokenOperationSuccess({
-        responsePayload: response.payload,
-      });
-      tokenMap.set(tokenSuccessResult.token.name, tokenSuccessResult.token);
+      if (action === "DELETE") {
+        const deletedTokenId = entityName.split("/").pop();
+        if (deletedTokenId) {
+          const tokenDeletionResult = handleTokenDeletion({
+            tokenId: deletedTokenId,
+            tokenMap,
+            userData,
+            deletedTokenIds,
+          });
+          if (tokenDeletionResult.removed) {
+            userData.tokens = tokenDeletionResult.updatedUserTokens;
+            eventHelper.notification.publish.creation(
+              tokenDeletionResult.notification!,
+            );
+          }
+        }
+      } else {
+        const tokenSuccessResult = handleTokenOperationSuccess({
+          responsePayload: response.payload,
+        });
+        tokenMap.set(tokenSuccessResult.token.name, tokenSuccessResult.token);
+      }
       break;
     case "user":
       if (action === "DELETE") {
-        userData = handleUserOperationError();
-        user = new User(userData);
+        const newUser = handleUserDelete();
+        userData = newUser;
+        user = new User(newUser);
+      }
+      break;
+    case "resource":
+      if (action === "DELETE") {
+        const tenant = originalData?.payload?.tenant;
+        const resourceName = originalData?.payload?.resource;
+        const resourceType = originalData?.payload?.kind;
+        if (tenant && resourceName && resourceType) {
+          setResourceDeleting(tenantsMap, tenant, resourceName, resourceType);
+        }
       }
       break;
   }
@@ -1458,10 +1715,12 @@ const handleOperationError = (operation: PendingOperation, error: any) => {
         error,
       });
 
+      const accErrorTenant = (originalData as Account)?.tenant;
+      const accErrorKey = accErrorTenant ? `${accErrorTenant}/${entityName}` : entityName;
       if (accErrorResult.shouldDelete) {
-        accountsMap.delete(entityName);
+        accountsMap.delete(accErrorKey);
       } else if (accErrorResult.updatedAccount) {
-        accountsMap.set(entityName, accErrorResult.updatedAccount);
+        accountsMap.set(accErrorKey, accErrorResult.updatedAccount);
       }
 
       if (accErrorResult.eventType === "creationError") {
@@ -1471,7 +1730,6 @@ const handleOperationError = (operation: PendingOperation, error: any) => {
       } else if (accErrorResult.eventType === "deletionError") {
         eventHelper.account.publish.deletionError(originalData);
       }
-      eventHelper.notification.publish.creation(accErrorResult.notification);
       break;
     case "environment":
       const envErrorResult = handleEnvironmentOperationError({
@@ -1488,7 +1746,9 @@ const handleOperationError = (operation: PendingOperation, error: any) => {
         eventHelper.environment.publish.deletionError(originalData);
       }
       eventHelper.notification.publish.creation(envErrorResult.notification);
-      environmentsMap.set(entityName, envErrorResult.updatedEnvironment);
+      const envErrOrigData = originalData as Environment;
+      const envErrorKey = envErrOrigData?.tenant && envErrOrigData?.account ? `${envErrOrigData.tenant}/${envErrOrigData.account}/${entityName}` : entityName;
+      environmentsMap.set(envErrorKey, envErrorResult.updatedEnvironment);
       break;
   }
   setTimeout(async () => {
@@ -1519,11 +1779,12 @@ const handleDeleteEvent = async (message: WSMessage) => {
   }
   if (keyParts.environment && !keyParts.service) {
     const environmentName = keyParts.environment;
-    const deletedEnv = environmentsMap.get(environmentName)!;
+    const envDeleteKey = tenantName && keyParts.account ? `${tenantName}/${keyParts.account}/${environmentName}` : environmentName;
+    const deletedEnv = environmentsMap.get(envDeleteKey)!;
     eventHelper.environment.publish.deleted(deletedEnv);
     const envNotification: Notification = {
       type: "success",
-      subtype: "environment-deleted",
+      subtype: errors.environment.deleted.subtype,
       date: Date.now().toString(),
       callToAction: false,
       status: "unread",
@@ -1534,15 +1795,16 @@ const handleDeleteEvent = async (message: WSMessage) => {
       },
     };
     eventHelper.notification.publish.creation(envNotification);
-    environmentsMap.delete(environmentName);
+    environmentsMap.delete(envDeleteKey);
   }
   if (keyParts.account && !keyParts.environment) {
     const accountName = keyParts.account;
-    const deletedAccount = accountsMap.get(accountName)!;
+    const accountDeleteKey = tenantName ? `${tenantName}/${accountName}` : accountName;
+    const deletedAccount = accountsMap.get(accountDeleteKey)!;
     eventHelper.account.publish.deleted(deletedAccount);
     const accountNotification: Notification = {
       type: "success",
-      subtype: "account-deleted",
+      subtype: errors.account.deleted.subtype,
       date: Date.now().toString(),
       callToAction: false,
       status: "unread",
@@ -1552,7 +1814,7 @@ const handleDeleteEvent = async (message: WSMessage) => {
       },
     };
     eventHelper.notification.publish.creation(accountNotification);
-    accountsMap.delete(accountName);
+    accountsMap.delete(accountDeleteKey);
   }
   if (keyParts.domain) {
     const domainName = keyParts.domain;
@@ -1680,7 +1942,7 @@ const handleDeleteEvent = async (message: WSMessage) => {
         tenantsMap.set(tenantName, registryTenant);
         const registryNotification: Notification = {
           type: "success",
-          subtype: "registry-deleted",
+          subtype: errors.registry.deleted.subtype,
           date: Date.now().toString(),
           status: "unread",
           callToAction: false,
@@ -1736,7 +1998,7 @@ const handleDeleteEvent = async (message: WSMessage) => {
     if (deletedLinkInfo) {
       const unlinkNotification: Notification = {
         type: "success",
-        subtype: "service-unlinked",
+        subtype: errors.service.unlinked.subtype,
         date: Date.now().toString(),
         status: "unread",
         callToAction: false,
@@ -1753,24 +2015,17 @@ const handleDeleteEvent = async (message: WSMessage) => {
     }
   }
   if (keyParts.token && keyParts.user) {
-    const tokenId = keyParts.token;
-    const tokenIndex = userData.tokens.findIndex((t) => t.name === tokenId);
-    if (tokenIndex !== -1) {
-      const deletedToken = userData.tokens[tokenIndex];
-      userData.tokens.splice(tokenIndex, 1);
-
-      const tokenNotification: Notification = {
-        type: "success",
-        subtype: "token-deleted",
-        date: Date.now().toString(),
-        status: "unread",
-        callToAction: false,
-        data: {
-          tokenName: deletedToken.name,
-          tenant: deletedToken.tenant,
-        },
-      };
-      eventHelper.notification.publish.creation(tokenNotification);
+    const tokenDeletionResult = handleTokenDeletion({
+      tokenId: keyParts.token,
+      tokenMap,
+      userData,
+      deletedTokenIds,
+    });
+    if (tokenDeletionResult.removed) {
+      userData.tokens = tokenDeletionResult.updatedUserTokens;
+      eventHelper.notification.publish.creation(
+        tokenDeletionResult.notification!,
+      );
     }
   }
   rebuildHierarchy();
@@ -1812,9 +2067,10 @@ const getChannelsInfo = async (
 const updateEnvironmentsCloudProvider = (
   accountId: string,
   cloudProviderName: string,
+  tenantId?: string,
 ) => {
   environmentsMap.forEach((environment, envId) => {
-    if (environment.account === accountId) {
+    if (environment.account === accountId && (!tenantId || environment.tenant === tenantId)) {
       environment.cloudProvider = cloudProviderName;
       environmentsMap.set(envId, environment);
     }
@@ -1832,7 +2088,8 @@ const loadReportingForEnvironment = async (environment: Environment) => {
       reportingData !== null &&
       Array.isArray(reportingData)
     ) {
-      const updatedEnvironment = environmentsMap.get(environment.id);
+      const envReportKey = environment.tenant && environment.account ? `${environment.tenant}/${environment.account}/${environment.id}` : environment.id;
+      const updatedEnvironment = environmentsMap.get(envReportKey);
 
       if (!updatedEnvironment) {
         console.warn(`Environment ${environment.id} not found in map`);
@@ -1863,7 +2120,7 @@ const loadReportingForEnvironment = async (environment: Environment) => {
           );
       }
 
-      environmentsMap.set(environment.id, updatedEnvironment);
+      environmentsMap.set(envReportKey, updatedEnvironment);
     }
   } catch (error) {
     console.error(
@@ -1895,8 +2152,20 @@ export const updateUserComplete = (updatedUserData: UserData): User => {
   try {
     const preservedNotifications =
       userData.notifications || updatedUserData.notifications || [];
+    const incomingTokenNames = new Set(
+      (updatedUserData.tokens || []).map((t) => t.name)
+    );
+    const localOnlyTokens = (userData.tokens || []).filter(
+      (t) => !incomingTokenNames.has(t.name)
+    );
+    const mergedTokens = [...(updatedUserData.tokens || []), ...localOnlyTokens]
+      .filter((t, index, arr) => arr.findIndex(x => x.name === t.name) === index)
+      .filter(t => tokenMap.size === 0 || tokenMap.has(t.name))
+      .filter(t => !deletedTokenIds.has(t.name));
+
     userData = {
       id: updatedUserData.id || userData.id,
+      created: updatedUserData.created || userData.created,
       name: updatedUserData.name || userData.name,
       surname: updatedUserData.surname || userData.surname,
       provider: updatedUserData.provider || userData.provider || [],
@@ -1906,7 +2175,7 @@ export const updateUserComplete = (updatedUserData: UserData): User => {
         "",
       organizations: updatedUserData.organizations || [],
       clusterTokens: updatedUserData.clusterTokens || [],
-      tokens: updatedUserData.tokens || [],
+      tokens: mergedTokens,
       tenants: updatedUserData.tenants || [],
       axebowPlan:
         updatedUserData.axebowPlan || userData.axebowPlan || "freemium",
@@ -1917,6 +2186,7 @@ export const updateUserComplete = (updatedUserData: UserData): User => {
       status: updatedUserData.status,
       discoveryMethod:
         updatedUserData.discoveryMethod || userData.discoveryMethod,
+      promotionInfo: computePromotionInfo(updatedUserData.tenants || userData.tenants || []),
     };
     user = new User(
       userData,
@@ -1935,7 +2205,7 @@ const resolveServiceStatus = (service: Service): Service => {
     return service;
   }
 
-  const revisionKey = `${service.tenant}/${service.name}-${service.currentRevision}`;
+  const revisionKey = `/tenant/${service.tenant}/service/${service.name}/revision/${service.currentRevision}`;
   const currentRevision = revisionsMap.get(revisionKey);
 
   if (!currentRevision) {
@@ -1963,3 +2233,58 @@ const resolveServiceStatus = (service: Service): Service => {
     status: currentRevision.status,
   };
 };
+export const fetchAndStoreMarketplaceSchema = async (
+  item: MarketplaceItem,
+): Promise<void> => {
+  const tenantsWithItem: string[] = [];
+  tenantsMap.forEach((tenantEntry, tenantId) => {
+    const hasItem = (tenantEntry.marketplaceItems || []).some(
+      (i) => i.name === item.name && i.domain === item.domain && i.artifact === item.artifact,
+    );
+    if (hasItem) tenantsWithItem.push(tenantId);
+  });
+
+  if (tenantsWithItem.length === 0) return;
+
+  await Promise.all(
+    tenantsWithItem.map(async (tenantId) => {
+      try {
+        const response = await makeGlobalWebSocketRequest(
+          "marketplace:artifact_schema",
+          {
+            tenant: tenantId,
+            module: item.name,
+            version: item.version,
+            domain: item.domain,
+            artifact: item.artifact,
+          },
+          30000,
+          "GET",
+          tenantId,
+        );
+
+        const data = response?.data;
+        if (!data) return;
+
+        const nameKeys = Object.keys(data);
+        const schema = processMarketplaceSchemaResponse(data[nameKeys[0]], nameKeys[0]);
+
+        const tenantEntry = tenantsMap.get(tenantId);
+        if (tenantEntry) {
+          tenantEntry.marketplaceItems = tenantEntry.marketplaceItems.map((i) =>
+            i.name === item.name && i.domain === item.domain && i.artifact === item.artifact
+              ? { ...i, schema }
+              : i,
+          );
+          tenantsMap.set(tenantId, tenantEntry);
+        }
+      } catch (error) {
+        console.error(`Error loading schema for tenant ${tenantId}:`, error);
+      }
+    }),
+  );
+
+  rebuildHierarchy();
+  await updateUserWithPlatformInfo();
+};
+