@uxland/primary-shell 7.42.0 → 7.43.1

package/dist/primary/shell/src/api/activity-monitor/activity-monitor.d.ts

@@ -0,0 +1,13 @@
+export interface ActivityMonitor {
+    start: () => void;
+    stop: () => void;
+    getLastActivityTimestamp: () => number;
+}
+export declare class ActivityMonitorImpl implements ActivityMonitor {
+    private lastActivityTimestamp;
+    private readonly activityHandler;
+    start: () => void;
+    stop: () => void;
+    getLastActivityTimestamp: () => number;
+}
+export declare const createActivityMonitor: () => ActivityMonitor;

package/dist/primary/shell/src/api/activity-monitor/activity-monitor.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/primary/shell/src/api/api.d.ts

@@ -32,6 +32,8 @@ export interface PrimariaApi extends HarmonixApi {
     importDataManager: PrimariaImportDataManager;
 }
 export declare const PrimariaRegionHost: any;
+export declare const activityMonitor: import('./activity-monitor/activity-monitor').ActivityMonitor;
+export declare const sessionRefreshTimer: import('./session-refresh-timer/session-refresh-timer').SessionRefreshTimer;
 /**
  * Factory function that creates a Primaria API instance.
  *

package/dist/primary/shell/src/api/session-refresh-timer/session-refresh-timer.d.ts

@@ -0,0 +1,20 @@
+import { ActivityMonitor } from '../activity-monitor/activity-monitor';
+import { PrimariaBroker } from '../broker/primaria-broker';
+import { TokenManager } from '../token-manager/token-manager';
+export interface SessionRefreshTimer {
+    start: () => void;
+    stop: () => void;
+}
+export declare class SessionRefreshTimerImpl implements SessionRefreshTimer {
+    private readonly tokenManager;
+    private readonly activityMonitor;
+    private readonly broker;
+    private intervalId;
+    private isRefreshing;
+    constructor(tokenManager: TokenManager, activityMonitor: ActivityMonitor, broker: PrimariaBroker);
+    start: () => void;
+    stop: () => void;
+    private getTokenExpiry;
+    private checkAndRefresh;
+}
+export declare const createSessionRefreshTimer: (tokenManager: TokenManager, activityMonitor: ActivityMonitor, broker: PrimariaBroker) => SessionRefreshTimer;

package/dist/primary/shell/src/api/session-refresh-timer/session-refresh-timer.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/primary/shell/src/api/token-manager/token-manager.d.ts

@@ -10,4 +10,4 @@ export declare class TokenManagerImpl implements TokenManager {
     getToken: () => string;
     refreshToken: () => Promise<string>;
 }
-export declare const createTokenManager: () => any;
+export declare const createTokenManager: () => TokenManagerImpl;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uxland/primary-shell",
-  "version": "7.42.0",
+  "version": "7.43.1",
   "description": "Primaria Shell",
   "author": "UXLand <dev@uxland.es>",
   "homepage": "https://github.com/uxland/harmonix/tree/app#readme",

package/src/api/activity-monitor/activity-monitor.test.ts

@@ -0,0 +1,67 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { ActivityMonitorImpl } from "./activity-monitor";
+
+describe("ActivityMonitor", () => {
+  let monitor: ActivityMonitorImpl;
+
+  beforeEach(() => {
+    vi.useFakeTimers();
+    monitor = new ActivityMonitorImpl();
+  });
+
+  afterEach(() => {
+    monitor.stop();
+    vi.useRealTimers();
+  });
+
+  it("should return 0 before any activity", () => {
+    expect(monitor.getLastActivityTimestamp()).toBe(0);
+  });
+
+  it("should update timestamp on keydown", () => {
+    monitor.start();
+    const before = Date.now();
+    window.dispatchEvent(new Event("keydown"));
+    expect(monitor.getLastActivityTimestamp()).toBeGreaterThanOrEqual(before);
+  });
+
+  it("should update timestamp on click", () => {
+    monitor.start();
+    const before = Date.now();
+    window.dispatchEvent(new Event("click"));
+    expect(monitor.getLastActivityTimestamp()).toBeGreaterThanOrEqual(before);
+  });
+
+  it("should update timestamp on scroll", () => {
+    monitor.start();
+    const before = Date.now();
+    window.dispatchEvent(new Event("scroll"));
+    expect(monitor.getLastActivityTimestamp()).toBeGreaterThanOrEqual(before);
+  });
+
+  it("should reflect the most recent activity time", () => {
+    monitor.start();
+
+    window.dispatchEvent(new Event("keydown"));
+    const first = monitor.getLastActivityTimestamp();
+
+    vi.advanceTimersByTime(5000);
+    window.dispatchEvent(new Event("click"));
+    const second = monitor.getLastActivityTimestamp();
+
+    expect(second).toBeGreaterThan(first);
+  });
+
+  it("should not update timestamp after stop", () => {
+    monitor.start();
+    window.dispatchEvent(new Event("keydown"));
+    const timestampBeforeStop = monitor.getLastActivityTimestamp();
+
+    monitor.stop();
+    vi.advanceTimersByTime(5000);
+    window.dispatchEvent(new Event("click"));
+
+    expect(monitor.getLastActivityTimestamp()).toBe(timestampBeforeStop);
+  });
+
+});

package/src/api/activity-monitor/activity-monitor.ts

@@ -0,0 +1,26 @@
+const ACTIVITY_EVENTS = ["keydown", "click", "scroll"] as const;
+
+export interface ActivityMonitor {
+  start: () => void;
+  stop: () => void;
+  getLastActivityTimestamp: () => number;
+}
+
+export class ActivityMonitorImpl implements ActivityMonitor {
+  private lastActivityTimestamp = 0;
+  private readonly activityHandler = () => {
+    this.lastActivityTimestamp = Date.now();
+  };
+
+  start = () => {
+    for (const e of ACTIVITY_EVENTS) window.addEventListener(e, this.activityHandler);
+  };
+
+  stop = () => {
+    for (const e of ACTIVITY_EVENTS) window.removeEventListener(e, this.activityHandler);
+  };
+
+  getLastActivityTimestamp = () => this.lastActivityTimestamp;
+}
+
+export const createActivityMonitor = (): ActivityMonitor => new ActivityMonitorImpl();

package/src/api/api.ts

@@ -5,8 +5,10 @@ import { PrimariaBroker } from "./broker/primaria-broker";
 import { EcapEventManager, createEcapEventManager } from "./ecap-event-manager/ecap-event-manager";
 import { ExitGuardManager, ExitGuardManagerImpl } from "./exit-guard-manager/exit-guard-manager";
 import { PrimariaGlobalStateManager, createGlobalStateManager } from "./global-state/global-state";
+import { createActivityMonitor } from "./activity-monitor/activity-monitor";
 import { HttpClient, createHttpClient } from "./http-client/http-client";
 import { PrimariaInteractionService } from "./interaction-service";
+import { createSessionRefreshTimer } from "./session-refresh-timer/session-refresh-timer";
 import { ParimariaInteractionServiceImpl } from "./interaction-service/interaction-service-impl";
 import { createLocaleManager } from "./localization/localization";
 import { PrimariaNotificationService } from "./notification-service/notification-service";
@@ -44,6 +46,8 @@ const regionManager: RegionManager = createRegionManager("primaria");
 export const PrimariaRegionHost: any = createRegionHost(regionManager as any);
 const tokenManager = createTokenManager();
 const userManager = createUserManager(tokenManager);
+export const activityMonitor = createActivityMonitor();
+export const sessionRefreshTimer = createSessionRefreshTimer(tokenManager, activityMonitor, broker);
 const globalStateManager: PrimariaGlobalStateManager = createGlobalStateManager(broker);
 const contextManager = createContextManager();
 const pluginBusyManager = new PluginBusyManagerImpl();

package/src/api/session-refresh-timer/session-refresh-timer.test.ts

@@ -0,0 +1,151 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { BROKER_EVENTS } from "../broker/broker-events";
+import { SessionRefreshTimerImpl } from "./session-refresh-timer";
+
+const createJwt = (exp: number): string => {
+  const payload = btoa(JSON.stringify({ exp }))
+    .replace(/=/g, "")
+    .replace(/\+/g, "-")
+    .replace(/\//g, "_");
+  return `header.${payload}.sig`;
+};
+
+const createMockTokenManager = (overrides: Record<string, any> = {}) => ({
+  getToken: vi.fn().mockReturnValue(createJwt(Math.floor(Date.now() / 1000) + 3600)),
+  setInitialTokens: vi.fn(),
+  refreshToken: vi.fn().mockResolvedValue("new_token"),
+  ...overrides,
+});
+
+const createMockActivityMonitor = (lastActivity = Date.now()) => ({
+  start: vi.fn(),
+  stop: vi.fn(),
+  getLastActivityTimestamp: vi.fn().mockReturnValue(lastActivity),
+});
+
+const createMockBroker = () => ({
+  publish: vi.fn().mockResolvedValue(undefined),
+  subscribe: vi.fn(),
+  send: vi.fn(),
+  registerRequest: vi.fn(),
+  events: BROKER_EVENTS,
+});
+
+describe("SessionRefreshTimer", () => {
+  let mockBroker: ReturnType<typeof createMockBroker>;
+
+  beforeEach(() => {
+    vi.useFakeTimers();
+    mockBroker = createMockBroker();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.clearAllMocks();
+  });
+
+  it("should skip tick when there is no recent activity", async () => {
+    const tokenManager = createMockTokenManager({
+      getToken: vi.fn().mockReturnValue(createJwt(Math.floor(Date.now() / 1000) + 60)),
+    });
+    const timer = new SessionRefreshTimerImpl(
+      tokenManager,
+      createMockActivityMonitor(0),
+      mockBroker,
+    );
+
+    timer.start();
+    await vi.advanceTimersByTimeAsync(30_000);
+
+    expect(tokenManager.refreshToken).not.toHaveBeenCalled();
+  });
+
+  it("should skip tick when token is not near expiry", async () => {
+    const tokenManager = createMockTokenManager({
+      getToken: vi.fn().mockReturnValue(createJwt(Math.floor(Date.now() / 1000) + 3600)),
+    });
+    const timer = new SessionRefreshTimerImpl(
+      tokenManager,
+      createMockActivityMonitor(),
+      mockBroker,
+    );
+
+    timer.start();
+    await vi.advanceTimersByTimeAsync(30_000);
+
+    expect(tokenManager.refreshToken).not.toHaveBeenCalled();
+  });
+
+  it("should refresh when token is near expiry and user is active", async () => {
+    const tokenManager = createMockTokenManager({
+      getToken: vi.fn().mockReturnValue(createJwt(Math.floor(Date.now() / 1000) + 60)),
+    });
+    const timer = new SessionRefreshTimerImpl(
+      tokenManager,
+      createMockActivityMonitor(),
+      mockBroker,
+    );
+
+    timer.start();
+    await vi.advanceTimersByTimeAsync(30_000);
+
+    expect(tokenManager.refreshToken).toHaveBeenCalledTimes(1);
+  });
+
+  it("should refresh when token is already expired and user is active", async () => {
+    const tokenManager = createMockTokenManager({
+      getToken: vi.fn().mockReturnValue(createJwt(Math.floor(Date.now() / 1000) - 60)),
+    });
+    const timer = new SessionRefreshTimerImpl(
+      tokenManager,
+      createMockActivityMonitor(),
+      mockBroker,
+    );
+
+    timer.start();
+    await vi.advanceTimersByTimeAsync(30_000);
+
+    expect(tokenManager.refreshToken).toHaveBeenCalledTimes(1);
+  });
+
+  it("should publish refreshTokenFailed when refresh throws", async () => {
+    const tokenManager = createMockTokenManager({
+      getToken: vi.fn().mockReturnValue(createJwt(Math.floor(Date.now() / 1000) - 60)),
+      refreshToken: vi.fn().mockRejectedValue(new Error("Refresh failed")),
+    });
+    const timer = new SessionRefreshTimerImpl(
+      tokenManager,
+      createMockActivityMonitor(),
+      mockBroker,
+    );
+
+    timer.start();
+    await vi.advanceTimersByTimeAsync(30_000);
+
+    expect(mockBroker.publish).toHaveBeenCalledWith(BROKER_EVENTS.shell.refreshTokenFailed, {});
+  });
+
+  it("should not trigger concurrent refreshes", async () => {
+    let resolveRefresh!: () => void;
+    const tokenManager = createMockTokenManager({
+      getToken: vi.fn().mockReturnValue(createJwt(Math.floor(Date.now() / 1000) + 60)),
+      refreshToken: vi.fn().mockImplementation(
+        () => new Promise((resolve) => { resolveRefresh = () => resolve("new_token"); }),
+      ),
+    });
+    const timer = new SessionRefreshTimerImpl(
+      tokenManager,
+      createMockActivityMonitor(),
+      mockBroker,
+    );
+
+    timer.start();
+    await vi.advanceTimersByTimeAsync(30_000);
+    await vi.advanceTimersByTimeAsync(30_000);
+
+    resolveRefresh();
+    await Promise.resolve();
+
+    expect(tokenManager.refreshToken).toHaveBeenCalledTimes(1);
+  });
+});

package/src/api/session-refresh-timer/session-refresh-timer.ts

@@ -0,0 +1,79 @@
+import { jwtDecode } from "jwt-decode";
+import { ActivityMonitor } from "../activity-monitor/activity-monitor";
+import { BROKER_EVENTS } from "../broker/broker-events";
+import { PrimariaBroker } from "../broker/primaria-broker";
+import { TokenManager } from "../token-manager/token-manager";
+
+const CHECK_INTERVAL_MS = 30_000;
+const REFRESH_THRESHOLD_S = 120;
+const ACTIVITY_WINDOW_MS = 15 * 60 * 1000;
+
+export interface SessionRefreshTimer {
+  start: () => void;
+  stop: () => void;
+}
+
+export class SessionRefreshTimerImpl implements SessionRefreshTimer {
+  private intervalId: ReturnType<typeof setInterval> | null = null;
+  private isRefreshing = false;
+
+  constructor(
+    private readonly tokenManager: TokenManager,
+    private readonly activityMonitor: ActivityMonitor,
+    private readonly broker: PrimariaBroker,
+  ) {}
+
+  start = () => {
+    this.intervalId = setInterval(this.checkAndRefresh, CHECK_INTERVAL_MS);
+  };
+
+  stop = () => {
+    if (this.intervalId !== null) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+    }
+  };
+
+  private getTokenExpiry = (): number => {
+    try {
+      const { exp } = jwtDecode(this.tokenManager.getToken()) as { exp?: number };
+      return exp ?? 0;
+    } catch {
+      return 0;
+    }
+  };
+
+  private checkAndRefresh = async () => {
+    const now = Date.now();
+
+    // Skip if the user hasn't interacted in the last ACTIVITY_WINDOW_MS.
+    // Avoids keeping sessions alive for unattended tabs.
+    if (now - this.activityMonitor.getLastActivityTimestamp() > ACTIVITY_WINDOW_MS) return;
+
+    // Skip if a refresh is already in flight (this interval can fire again before the previous awaits).
+    if (this.isRefreshing) return;
+
+    const exp = this.getTokenExpiry();
+
+    // Skip if the token can't be decoded (e.g. not yet initialized).
+    if (exp === 0) return;
+
+    // exp is in seconds, now is in milliseconds — compare in the same unit.
+    if (exp - now / 1000 <= REFRESH_THRESHOLD_S) {
+      this.isRefreshing = true;
+      try {
+        await this.tokenManager.refreshToken();
+      } catch {
+        this.broker.publish(BROKER_EVENTS.shell.refreshTokenFailed, {});
+      } finally {
+        this.isRefreshing = false;
+      }
+    }
+  };
+}
+
+export const createSessionRefreshTimer = (
+  tokenManager: TokenManager,
+  activityMonitor: ActivityMonitor,
+  broker: PrimariaBroker,
+): SessionRefreshTimer => new SessionRefreshTimerImpl(tokenManager, activityMonitor, broker);

package/src/api/token-manager/token-manager.test.ts

@@ -3,10 +3,10 @@ import axios from "axios";
 
 vi.mock("axios");
 
-const access_token = 'test_access_token';
-const refresh_token = 'test_refresh_token';
-const new_access_token = 'new_access_token';
-const new_refresh_token = 'new_refresh_token';
+const access_token = "test_access_token";
+const refresh_token = "test_refresh_token";
+const new_access_token = "new_access_token";
+const new_refresh_token = "new_refresh_token";
 
 describe("TokenManager", () => {
   let mockLocation: Partial<Location>;
@@ -14,14 +14,12 @@ describe("TokenManager", () => {
   let createTokenManager: any;
 
   beforeEach(async () => {
-    // Reset module state by requiring a fresh instance
     vi.resetModules();
     mockLocation = {
-      search: `?access_token=${access_token}&refresh_token=${refresh_token}`
+      search: `?access_token=${access_token}&refresh_token=${refresh_token}`,
     };
-    vi.spyOn(window, 'location', 'get').mockReturnValue(mockLocation as Location);
+    vi.spyOn(window, "location", "get").mockReturnValue(mockLocation as Location);
 
-    // Import fresh module
     const module = await import("./token-manager");
     TokenManagerImpl = module.TokenManagerImpl;
     createTokenManager = module.createTokenManager;
@@ -34,23 +32,18 @@ describe("TokenManager", () => {
   describe("getToken", () => {
     it("should initialize token from URL params on first call", () => {
       const tokenManager = new TokenManagerImpl();
-      const token = tokenManager.getToken();
-      expect(token).toBe(access_token);
+      expect(tokenManager.getToken()).toBe(access_token);
     });
 
     it("should return empty string if URL params are missing", () => {
       mockLocation.search = "";
       const tokenManager = new TokenManagerImpl();
-      const token = tokenManager.getToken();
-      expect(token).toBe("");
+      expect(tokenManager.getToken()).toBe("");
     });
 
     it("should return the same token on subsequent calls", () => {
       const tokenManager = new TokenManagerImpl();
-      const token1 = tokenManager.getToken();
-      const token2 = tokenManager.getToken();
-      expect(token1).toBe(token2);
-      expect(token1).toBe(access_token);
+      expect(tokenManager.getToken()).toBe(tokenManager.getToken());
     });
   });
 
@@ -64,67 +57,58 @@ describe("TokenManager", () => {
     it("should throw error if tokens are already initialized", () => {
       const tokenManager = new TokenManagerImpl();
       tokenManager.setInitialTokens("manual_access", "manual_refresh");
-      expect(() => tokenManager.setInitialTokens("another_access", "another_refresh"))
-        .toThrow("Token already initialized");
+      expect(() => tokenManager.setInitialTokens("another_access", "another_refresh")).toThrow(
+        "Token already initialized",
+      );
     });
 
     it("should throw error if tokens were already initialized from URL", () => {
       const tokenManager = new TokenManagerImpl();
-      tokenManager.getToken(); // Initialize from URL
-      expect(() => tokenManager.setInitialTokens("manual_access", "manual_refresh"))
-        .toThrow("Token already initialized");
+      tokenManager.getToken();
+      expect(() => tokenManager.setInitialTokens("manual_access", "manual_refresh")).toThrow(
+        "Token already initialized",
+      );
     });
   });
 
   describe("refreshToken", () => {
     it("should refresh token successfully", async () => {
       vi.mocked(axios.post).mockResolvedValue({
-        data: {
-          access_token: new_access_token,
-          refresh_token: new_refresh_token
-        }
+        data: { access_token: new_access_token, refresh_token: new_refresh_token },
       });
 
       const tokenManager = new TokenManagerImpl();
       tokenManager.setInitialTokens(access_token, refresh_token);
 
-      const refreshedToken = await tokenManager.refreshToken();
+      const refreshed = await tokenManager.refreshToken();
 
-      expect(axios.post).toHaveBeenCalledWith('/api/token/refresh', { token: refresh_token });
-      expect(refreshedToken).toBe(new_access_token);
+      expect(axios.post).toHaveBeenCalledWith("/api/token/refresh", { token: refresh_token });
+      expect(refreshed).toBe(new_access_token);
       expect(tokenManager.getToken()).toBe(new_access_token);
     });
 
     it("should initialize tokens from URL before refreshing if not initialized", async () => {
       vi.mocked(axios.post).mockResolvedValue({
-        data: {
-          access_token: new_access_token,
-          refresh_token: new_refresh_token
-        }
+        data: { access_token: new_access_token, refresh_token: new_refresh_token },
       });
 
       const tokenManager = new TokenManagerImpl();
       await tokenManager.refreshToken();
 
-      expect(axios.post).toHaveBeenCalledWith('/api/token/refresh', { token: refresh_token });
-      expect(tokenManager.getToken()).toBe(new_access_token);
+      expect(axios.post).toHaveBeenCalledWith("/api/token/refresh", { token: refresh_token });
     });
 
     it("should throw error if refresh response doesn't contain access_token", async () => {
-      vi.mocked(axios.post).mockResolvedValue({
-        data: {}
-      });
+      vi.mocked(axios.post).mockResolvedValue({ data: {} });
 
       const tokenManager = new TokenManagerImpl();
       tokenManager.setInitialTokens(access_token, refresh_token);
 
-      await expect(tokenManager.refreshToken())
-        .rejects.toThrow("Invalid refresh token response");
+      await expect(tokenManager.refreshToken()).rejects.toThrow("Invalid refresh token response");
     });
 
     it("should handle axios errors", async () => {
-      const error = new Error("Network error");
-      vi.mocked(axios.post).mockRejectedValue(error);
+      vi.mocked(axios.post).mockRejectedValue(new Error("Network error"));
 
       const tokenManager = new TokenManagerImpl();
       tokenManager.setInitialTokens(access_token, refresh_token);
@@ -135,9 +119,7 @@ describe("TokenManager", () => {
 
   describe("createTokenManager", () => {
     it("should return a singleton instance", () => {
-      const tokenManager1 = createTokenManager();
-      const tokenManager2 = createTokenManager();
-      expect(tokenManager1).toBe(tokenManager2);
+      expect(createTokenManager()).toBe(createTokenManager());
     });
   });
 });

package/src/api/token-manager/token-manager.ts

@@ -9,14 +9,14 @@ export interface TokenManager {
 let token: string;
 let refreshToken: string;
 let tokenInitialized = false;
+
 export class TokenManagerImpl implements TokenManager {
   getUrlParams = (): URLSearchParams => {
     return new URLSearchParams(window.location.search);
   };
 
   private initToken = () => {
-    if (tokenInitialized)
-      throw new Error("Token already initialized");
+    if (tokenInitialized) throw new Error("Token already initialized");
     tokenInitialized = true;
     const searchString = this.getUrlParams();
     token = searchString.get("access_token") || "";
@@ -25,37 +25,32 @@ export class TokenManagerImpl implements TokenManager {
   };
 
   setInitialTokens = (access_token: string, refresh_token: string) => {
-    if (tokenInitialized)
-      throw new Error("Token already initialized");
+    if (tokenInitialized) throw new Error("Token already initialized");
     token = access_token;
     refreshToken = refresh_token;
     tokenInitialized = true;
   };
 
   getToken = () => {
-    if (!tokenInitialized)
-      this.initToken();
+    if (!tokenInitialized) this.initToken();
     return token;
   };
 
   refreshToken = async () => {
-    if (!tokenInitialized) {
-      this.initToken();
-    }
-    const response = await axios.post('/api/token/refresh', {token: refreshToken});
-    const {access_token, refresh_token} = response.data;
-    if(!access_token){
-      throw new Error("Invalid refresh token response");
-    }
+    if (!tokenInitialized) this.initToken();
+    const response = await axios.post("/api/token/refresh", { token: refreshToken });
+    const { access_token, refresh_token } = response.data;
+    if (!access_token) throw new Error("Invalid refresh token response");
     token = access_token;
     refreshToken = refresh_token;
     return token;
   };
 }
-let tokenManager;
-export const createTokenManager = () =>  {
-  if(tokenManager) return tokenManager;
+
+let tokenManager: TokenManagerImpl;
+
+export const createTokenManager = () => {
+  if (tokenManager) return tokenManager;
   tokenManager = new TokenManagerImpl();
-  //tokenManager.initToken();
   return tokenManager;
-}
+};

package/src/bootstrapper.ts

@@ -1,16 +1,17 @@
 import { PrimariaShell } from "./UI/components/primaria-shell/primaria-shell";
-import { shellApi } from "./api/api";
+import { activityMonitor, sessionRefreshTimer, shellApi } from "./api/api";
 import { EcapContext } from "./api/context-manager/context-manager";
 import { useFeatures } from "./features/bootstrapper";
 import { useLocalization } from "./locales";
 import { useUI } from "./UI/bootstrapper";
 
 export const initializeShell = (hostAppElement: HTMLElement, ecapContext?: EcapContext) => {
-  // Initialize the context manager with ECAP parameters
   if (ecapContext) {
     (shellApi.contextManager as any).initializeContext(ecapContext);
   }
 
+  activityMonitor.start();
+  sessionRefreshTimer.start();
   useLocalization(shellApi);
   useUI();
   useFeatures(shellApi);

package/src/disposer.ts

@@ -1,9 +1,11 @@
-import { shellApi } from "./api/api";
+import { activityMonitor, sessionRefreshTimer, shellApi } from "./api/api";
 import { disposeFeatures } from "./features/bootstrapper";
 import { ExitShellPayload } from "./features/exit/request";
 export const disposeShell = () => {
   disposeFeatures(shellApi);
   shellApi.interactionService.dispose();
+  sessionRefreshTimer.stop();
+  activityMonitor.stop();
 };
 
 export const raiseCloseEvent = () => {