@jmruthers/pace-core 0.5.181 → 0.5.182

package/src/{types/rbac-functions.ts → rbac/types/functions.ts}

@@ -1,25 +1,27 @@
 /**
  * @file RBAC Function Types
  * @package @jmruthers/pace-core
- * @module RBAC/Types
+ * @module RBAC/Types/Functions
  * @since 1.0.0
  * 
- * TypeScript types for standardized RBAC functions.
+ * TypeScript types for standardized RBAC RPC functions.
+ * These types define the parameters and return types for database RPC functions.
  */
 
-import { UUID } from '../rbac/types';
+import type { UUID, Operation } from '../types';
+import type { AppId, PageId } from '../../types/core';
 
 // ============================================================================
 // PERMISSION CHECKING FUNCTION TYPES
 // ============================================================================
 
 export interface RBACPermissionCheckParams {
-  p_operation: string;
+  p_operation: Operation;
   p_page_name: string;
   p_user_id?: UUID;
   p_organisation_id?: UUID;
   p_event_id?: string;
-  p_app_id?: UUID;
+  p_app_id?: AppId | UUID;
 }
 
 export interface RBACPermissionCheckResult {
@@ -33,8 +35,8 @@ export interface RBACPermissionsGetParams {
   p_user_id: UUID; // REQUIRED - no default, must be explicitly provided
   p_organisation_id?: UUID;
   p_event_id?: string;
-  p_app_id?: UUID;
-  p_page_id?: UUID;
+  p_app_id?: AppId | UUID;
+  p_page_id?: PageId | UUID;
 }
 
 export interface RBACPermissionsGetResult {
@@ -49,19 +51,19 @@ export interface RBACAccessValidateParams {
   p_resource_type: 'organisation' | 'event';
   p_resource_id: string;
   p_user_id?: UUID;
-  p_operation?: string;
+  p_operation?: Operation;
 }
 
 export interface RBACAccessValidateResult {
   has_access: boolean;
-  access_level: 'super_admin' | 'organisation' | 'event' | 'none';
+  access_level: AccessLevelContext;
   context_id: string | null;
 }
 
 export interface RBACPageAccessCheckParams {
-  p_app_id: UUID;
-  p_page_id: string;
-  p_operation: string;
+  p_app_id: AppId | UUID;
+  p_page_id: PageId | UUID;
+  p_operation: Operation;
   p_user_id?: UUID;
   p_event_id?: string;
   p_organisation_id?: UUID;
@@ -105,7 +107,7 @@ export interface RBACRolesListParams {
   p_user_id?: UUID;
   p_organisation_id?: UUID;
   p_event_id?: string;
-  p_app_id?: UUID;
+  p_app_id?: AppId | UUID;
 }
 
 export interface RBACRolesListResult {
@@ -140,7 +142,7 @@ export interface RBACSessionTrackParams {
   p_user_id?: UUID;
   p_session_type?: 'web' | 'mobile' | 'api' | 'admin';
   p_event_id?: string;
-  p_app_id?: UUID;
+  p_app_id?: AppId | UUID;
   p_ip_address?: string;
   p_user_agent?: string;
 }
@@ -157,7 +159,7 @@ export interface RBACAuditLogParams {
   p_user_id?: UUID;
   p_organisation_id?: UUID;
   p_permission?: string;
-  p_metadata?: Record<string, any>;
+  p_metadata?: Record<string, unknown>;
   p_ip_address?: string;
   p_user_agent?: string;
 }
@@ -218,23 +220,20 @@ export enum RBACErrorCode {
   GRANTED_BY_NOT_FOUND = 'GRANTED_BY_NOT_FOUND',
 }
 
-// ============================================================================
-// ROLE TYPES
-// ============================================================================
-
-export type GlobalRole = 'super_admin';
-export type OrganisationRole = 'supporter' | 'member' | 'leader' | 'org_admin';
-export type EventAppRole = 'viewer' | 'participant' | 'planner' | 'event_admin';
-
-export type RBACRole = GlobalRole | OrganisationRole | EventAppRole;
-
 // ============================================================================
 // PERMISSION TYPES
 // ============================================================================
 
-export type PermissionOperation = 'read' | 'create' | 'update' | 'delete';
+/**
+ * Permission source indicates where a permission was granted from
+ */
 export type PermissionSource = 'global' | 'organisation' | 'event_app' | 'default' | 'none';
-export type AccessLevel = 'super_admin' | 'organisation' | 'event' | 'none';
+
+/**
+ * Access level context for RPC functions (different from RBAC AccessLevel)
+ * Indicates the scope/context of access validation
+ */
+export type AccessLevelContext = 'super_admin' | 'organisation' | 'event' | 'none';
 
 // ============================================================================
 // SESSION TYPES
@@ -268,10 +267,10 @@ export interface RBACContext {
   user_id: UUID;
   organisation_id?: UUID;
   event_id?: string;
-  app_id?: UUID;
+  app_id?: AppId | UUID;
 }
 
-export interface RBACResult<T = any> {
+export interface RBACResult<T = unknown> {
   success: boolean;
   data?: T;
   error?: string;
@@ -284,8 +283,9 @@ export interface RBACResult<T = any> {
 
 export type RBACFunctionResponse<T> = {
   data: T | null;
-  error: any | null;
+  error: unknown | null;
   count?: number | null;
   status: number;
   statusText: string;
 };
+

package/src/rbac/types.ts

@@ -9,6 +9,7 @@
  */
 
 import type React from 'react';
+import type { AppId, PageId } from '../types/core';
 
 // ============================================================================
 // CORE TYPES
@@ -30,14 +31,14 @@ export type AccessLevel =
 export type Scope = {
   organisationId?: UUID;
   eventId?: string; // event_id is text/varchar
-  appId?: UUID;
+  appId?: AppId | UUID;
 };
 
 export type PermissionCheck = {
   userId: UUID;
   scope: Scope;
   permission: Permission;
-  pageId?: UUID | string;
+  pageId?: PageId | UUID;
 };
 
 export type PermissionMap = Record<Permission, boolean> & Partial<Record<'*', boolean>>;

package/src/services/AuthService.ts

@@ -8,19 +8,27 @@
  * Handles user authentication, session management, and auth-related operations.
  */
 
-import { type SupabaseClient, type User, type Session, AuthError } from '@supabase/supabase-js';
+import { type SupabaseClient, type User, type Session, AuthError, type AuthChangeEvent, type Session as SupabaseSession } from '@supabase/supabase-js';
 import type { SessionRestorationState } from '../types/auth';
 import { BaseService } from './base/BaseService';
 import { IAuthService, AuthResult } from './interfaces/IAuthService';
 import { logger } from '../utils/core/logger';
 
+type AuthStateSubscription = {
+  data: {
+    subscription: {
+      unsubscribe: () => void;
+    };
+  };
+};
+
 export class AuthService extends BaseService implements IAuthService {
   private user: User | null = null;
   private session: Session | null = null;
   private authLoading = false;
   private authError: AuthError | null = null;
   private supabaseClient: SupabaseClient | null = null;
-  private authStateSubscription: any = null;
+  private authStateSubscription: { unsubscribe: () => void } | null = null;
   private sessionRestorationState: SessionRestorationState = {
     isRestoring: false,
     restorationComplete: false,
@@ -30,6 +38,8 @@ export class AuthService extends BaseService implements IAuthService {
   private readonly restorationTimeoutMs = 5000;
   private restorationStartTime: number | null = null;
   private appName: string | undefined = undefined;
+  private errorHandler: ((event: ErrorEvent) => void) | null = null;
+  private unhandledRejectionHandler: ((event: PromiseRejectionEvent) => void) | null = null;
 
   constructor(supabaseClient: SupabaseClient, appName?: string) {
     super();
@@ -294,7 +304,7 @@ export class AuthService extends BaseService implements IAuthService {
   }
 
   cleanup(): void {
-    if (this.authStateSubscription && typeof this.authStateSubscription.unsubscribe === 'function') {
+    if (this.authStateSubscription) {
       this.authStateSubscription.unsubscribe();
       this.authStateSubscription = null;
     }
@@ -328,7 +338,6 @@ export class AuthService extends BaseService implements IAuthService {
     };
     this.authLoading = true;
     this.restorationStartTime = Date.now();
-    logger.debug('AuthService', 'Starting session restoration at', this.restorationStartTime);
     this.notify();
 
     this.restorationTimeoutId = setTimeout(() => {
@@ -357,9 +366,7 @@ export class AuthService extends BaseService implements IAuthService {
     this.authLoading = false;
 
     if (error) {
-      logger.warn('AuthService', 'Session restoration finished with error:', error, 'duration(ms):', duration ?? 'unknown');
-    } else {
-      logger.debug('AuthService', 'Session restoration completed successfully in', duration ?? 'unknown', 'ms');
+      logger.warn('AuthService', 'Session restoration finished with error:', error);
     }
 
     this.notify();
@@ -380,10 +387,9 @@ export class AuthService extends BaseService implements IAuthService {
     }
 
     try {
-      this.authStateSubscription = this.supabaseClient.auth.onAuthStateChange(
-        (event, session) => {
+      const subscription = this.supabaseClient.auth.onAuthStateChange(
+        (event: AuthChangeEvent, session: SupabaseSession | null) => {
           try {
-            logger.debug('AuthService', 'Auth state change event received:', event);
             // Handle different auth events
             if (event === 'SIGNED_OUT') {
               this.session = null;
@@ -445,6 +451,7 @@ export class AuthService extends BaseService implements IAuthService {
           }
         }
       );
+      this.authStateSubscription = subscription.data.subscription;
     } catch (error) {
       logger.error('AuthService', 'Failed to setup auth state listener:', error);
       throw error; // Re-throw to propagate to the provider
@@ -462,7 +469,6 @@ export class AuthService extends BaseService implements IAuthService {
     this.startSessionRestoration();
 
     try {
-      logger.debug('AuthService', 'Fetching existing session from Supabase');
       let currentSession: Session | null = null;
       let sessionError: AuthError | null = null;
 
@@ -472,14 +478,12 @@ export class AuthService extends BaseService implements IAuthService {
         sessionError = error ?? null;
       } catch (error) {
         // Handle cases where getSession might not exist (mocked/test clients)
-        logger.debug('AuthService', 'getSession unavailable, treating as no active session');
         currentSession = null;
         sessionError = null;
       }
 
       if (sessionError) {
         // Record error but continue to attempt getUser to satisfy edge cases
-        logger.debug('AuthService', 'getSession returned error, attempting to fetch user anyway');
         this.authError = sessionError;
         
         // Attempt getUser as fallback when getSession fails
@@ -498,7 +502,6 @@ export class AuthService extends BaseService implements IAuthService {
           }
         } catch (getUserError) {
           // If getUser also fails, we've already recorded the sessionError
-          logger.debug('AuthService', 'getUser also failed:', getUserError);
         }
       }
 
@@ -510,7 +513,7 @@ export class AuthService extends BaseService implements IAuthService {
         // Only skip getUser if we didn't already attempt it due to a sessionError
         // Treat missing session as a normal cold-start state on public pages (e.g., login)
         // Do not call getUser() which can raise AuthSessionMissingError and surface a noisy banner
-        logger.debug('AuthService', 'No active session found; treating as normal unauthenticated state');
+        // No active session found; treating as normal unauthenticated state
         this.session = null;
         this.user = null;
         this.authError = null;
@@ -570,7 +573,8 @@ export class AuthService extends BaseService implements IAuthService {
 
       // Call rbac_session_track RPC function
       // This automatically inserts into rbac_user_sessions AND rbac_user_login_history (for login)
-      const { error } = await (this.supabaseClient as any).rpc('rbac_session_track', {
+      // Note: Using type assertion for RPC call as Supabase doesn't provide full typing for custom RPC functions
+      const { error } = await (this.supabaseClient as unknown as { rpc: (name: string, params: Record<string, unknown>) => Promise<{ error: Error | null }> }).rpc('rbac_session_track', {
         p_user_id: session.user.id,
         p_session_type: sessionType,
         p_event_id: null, // Event ID should come from context, not auth service
@@ -582,8 +586,6 @@ export class AuthService extends BaseService implements IAuthService {
 
       if (error) {
         logger.warn('AuthService', `Failed to track ${sessionType} session:`, error);
-      } else {
-        logger.debug('AuthService', `Successfully tracked ${sessionType} session`);
       }
     } catch (error) {
       // Log error but don't throw (non-blocking)
@@ -594,7 +596,7 @@ export class AuthService extends BaseService implements IAuthService {
   private setupErrorHandlers(): void {
     if (typeof window === 'undefined') return;
 
-    const handleError = (event: ErrorEvent) => {
+    this.errorHandler = (event: ErrorEvent) => {
       if (event.error?.message?.includes('AuthSessionMissingError') || 
           event.error?.message?.includes('Auth session missing')) {
         logger.warn('AuthService', 'Suppressing AuthSessionMissingError during logout');
@@ -603,7 +605,7 @@ export class AuthService extends BaseService implements IAuthService {
       }
     };
 
-    const handleUnhandledRejection = (event: PromiseRejectionEvent) => {
+    this.unhandledRejectionHandler = (event: PromiseRejectionEvent) => {
       if (event.reason?.message?.includes('AuthSessionMissingError') ||
           event.reason?.message?.includes('Auth session missing')) {
         logger.warn('AuthService', 'Suppressing unhandled AuthSessionMissingError');
@@ -612,15 +614,21 @@ export class AuthService extends BaseService implements IAuthService {
       }
     };
 
-    window.addEventListener('error', handleError);
-    window.addEventListener('unhandledrejection', handleUnhandledRejection);
+    window.addEventListener('error', this.errorHandler);
+    window.addEventListener('unhandledrejection', this.unhandledRejectionHandler);
   }
 
   private removeErrorHandlers(): void {
     if (typeof window === 'undefined') return;
 
-    // Note: We can't remove specific handlers without storing references
-    // In a real implementation, you'd store the handler references
-    // For now, we'll rely on the service being cleaned up
+    if (this.errorHandler) {
+      window.removeEventListener('error', this.errorHandler);
+      this.errorHandler = null;
+    }
+
+    if (this.unhandledRejectionHandler) {
+      window.removeEventListener('unhandledrejection', this.unhandledRejectionHandler);
+      this.unhandledRejectionHandler = null;
+    }
   }
 }

package/src/services/EventService.ts

@@ -11,8 +11,9 @@
 import { type SupabaseClient, type User, type Session } from '@supabase/supabase-js';
 import { BaseService } from './base/BaseService';
 import { IEventService } from './interfaces/IEventService';
-import { Event } from '../types/unified';
+import { Event } from '../types/event';
 import { Organisation } from '../types/organisation';
+import { assertOrganisationId } from '../types/core';
 import { logger } from '../utils/core/logger';
 import { secureStorage } from '../utils/security/secureStorage';
 
@@ -101,8 +102,12 @@ export class EventService extends BaseService implements IEventService {
       this.resetInitialization(); // Reset BaseService's isInitialized flag
       this.isInitializedRef = false;
       this.isFetchingRef = false;
-      // Clear events when switching organisations
-      if (previousOrgId !== null && newOrgId !== previousOrgId) {
+      // Clear events ONLY when switching between different organisations (not when org first becomes available)
+      if (previousOrgId !== null && newOrgId !== null && previousOrgId !== newOrgId) {
+        this.events = [];
+        this.selectedEvent = null;
+      } else if (previousOrgId !== null && newOrgId === null) {
+        // Organisation was removed - clear events
         this.events = [];
         this.selectedEvent = null;
       }
@@ -113,7 +118,9 @@ export class EventService extends BaseService implements IEventService {
 
   // Event state getters
   getEvents(): Event[] {
-    return this.events;
+    // Return a new array reference so React can detect changes
+    // This ensures useMemo dependencies work correctly
+    return [...this.events];
   }
 
   getSelectedEvent(): Event | null {
@@ -277,27 +284,9 @@ export class EventService extends BaseService implements IEventService {
 
   // Lifecycle methods
   async initialize(): Promise<void> {
+    // Only call super.initialize() which will call doInitialize() and fetchEvents()
+    // Don't call fetchEvents() again here to avoid double-fetching
     await super.initialize();
-    
-    // Clean up old global storage keys (backward compatibility)
-    // This ensures old data doesn't leak to new users
-    try {
-      // Remove old plain storage key
-      if (typeof sessionStorage !== 'undefined') {
-        sessionStorage.removeItem('pace-core-selected-event');
-      }
-      if (typeof localStorage !== 'undefined') {
-        localStorage.removeItem('pace-core-selected-event');
-        // Also remove old encrypted format if it exists
-        localStorage.removeItem('_sec_pace-core-selected-event');
-      }
-    } catch (error) {
-      logger.warn('EventService', 'Failed to clean up old storage keys:', error);
-    }
-    
-    // Load persisted event during initialization (don't skip)
-    // This ensures the last viewed event is restored before auto-selection happens
-    await this.fetchEvents(false);
   }
 
   cleanup(): void {
@@ -305,8 +294,32 @@ export class EventService extends BaseService implements IEventService {
   }
 
   protected async doInitialize(): Promise<void> {
+    // Skip if already initialized
+    if (this.isInitializedRef) {
+      return;
+    }
+    
+    // Skip if already fetching
+    if (this.isFetchingRef) {
+      return;
+    }
+    
+    // Clean up old storage keys (migration from old key format)
+    try {
+      sessionStorage.removeItem('pace-core-selected-event');
+      localStorage.removeItem('pace-core-selected-event');
+      localStorage.removeItem('_sec_pace-core-selected-event');
+    } catch (error) {
+      logger.warn('EventService', 'Failed to clean up old storage keys:', error);
+    }
+    
+    // Skip if no user or organisation
+    if (!this.user || !this.selectedOrganisation) {
+      return;
+    }
+    
     // Initial setup - fetch events on initialization
-    await this.fetchEvents();
+    await this.fetchEvents(false);
   }
 
   protected doCleanup(): void {
@@ -334,25 +347,12 @@ export class EventService extends BaseService implements IEventService {
 
     try {
       // Call the RPC function following the established pattern
-      logger.debug('EventService', 'Fetching events with params:', {
-        p_user_id: this.user.id,
-        p_organisation_id: this.selectedOrganisation.id,
-        p_app_name: this.appName
-      });
-      
       const { data, error: rpcError } = await this.supabaseClient.rpc('data_user_events_get', {
         p_user_id: this.user.id,
         p_organisation_id: this.selectedOrganisation.id,
         p_app_name: this.appName
       });
 
-      logger.debug('EventService', 'RPC call completed:', {
-        hasData: !!data,
-        dataLength: Array.isArray(data) ? data.length : 0,
-        hasError: !!rpcError,
-        errorMessage: rpcError?.message || 'No error'
-      });
-
       if (rpcError) {
         logger.error('EventService', 'RPC error fetching events:', rpcError);
         throw new Error(rpcError.message || 'Failed to fetch events');
@@ -362,8 +362,21 @@ export class EventService extends BaseService implements IEventService {
         const eventsData = data || [];
 
         // Transform the data to match our Event interface
-        const transformedEvents: Event[] = eventsData.map((event: any) => ({
-          id: event.event_id, // Use event_id as the primary id
+        // Type for RPC response from data_user_events_get
+        interface EventRpcResponse {
+          event_id: string;
+          event_name: string;
+          event_code: string;
+          event_date: string | null;
+          event_venue: string | null;
+          event_participants: number | null;
+          event_colours: Record<string, unknown> | null;
+          organisation_id: string;
+          is_visible: boolean;
+        }
+        
+        const transformedEvents: Event[] = eventsData.map((event: EventRpcResponse) => ({
+          id: event.event_id,
           event_id: event.event_id,
           event_name: event.event_name,
           event_code: event.event_code,
@@ -372,11 +385,10 @@ export class EventService extends BaseService implements IEventService {
           event_participants: event.event_participants,
           event_colours: event.event_colours,
           event_logo: '', // No logo field in event table
-          organisation_id: event.organisation_id,
+          organisation_id: assertOrganisationId(event.organisation_id),
           is_visible: event.is_visible,
-          // Legacy compatibility
-          name: event.event_name,
-          start_date: event.event_date
+          created_at: new Date().toISOString(),
+          updated_at: new Date().toISOString()
         }));
 
         this.events = transformedEvents;

package/src/services/InactivityService.ts

@@ -8,10 +8,22 @@
  * Handles inactivity tracking, auto-logout, and warning modals.
  */
 
+import { type SupabaseClient, type User, type Session } from '@supabase/supabase-js';
 import { BaseService } from './base/BaseService';
 import { IInactivityService } from './interfaces/IInactivityService';
 import { logger } from '../utils/core/logger';
 
+interface InactivityTracker {
+  isIdle: boolean;
+  timeRemaining: number;
+  showWarning: boolean;
+  isTracking: boolean;
+  resetActivity: () => void;
+  startTracking: () => void;
+  stopTracking: () => void;
+  cleanup?: () => void;
+}
+
 export class InactivityService extends BaseService implements IInactivityService {
   private _showInactivityWarning = false;
   private _inactivityTimeRemaining = 0;
@@ -21,21 +33,22 @@ export class InactivityService extends BaseService implements IInactivityService
   private _isTracking = false;
 
   // Dependencies
-  private supabaseClient: any = null;
-  private user: any = null;
-  private session: any = null;
+  private supabaseClient: SupabaseClient | null = null;
+  private user: User | null = null;
+  private session: Session | null = null;
   private idleTimeoutMs = 30 * 60 * 1000; // 30 minutes
   private warnBeforeMs = 60 * 1000; // 60 seconds
   private onIdleLogout: ((reason: 'inactivity') => void) | null = null;
 
   // Internal state management
-  private inactivityTracker: any = null;
+  private inactivityTracker: InactivityTracker | null = null;
   private isInactivityEnabled = true;
+  private cleanupHandlers: (() => void) | null = null;
 
   constructor(
-    supabaseClient: any,
-    user: any,
-    session: any,
+    supabaseClient: SupabaseClient | null,
+    user: User | null,
+    session: Session | null,
     idleTimeoutMs: number = 30 * 60 * 1000,
     warnBeforeMs: number = 60 * 1000,
     onIdleLogout: (reason: 'inactivity') => void
@@ -111,9 +124,9 @@ export class InactivityService extends BaseService implements IInactivityService
 
   // Update dependencies
   updateDependencies(
-    supabaseClient: any,
-    user: any,
-    session: any,
+    supabaseClient: SupabaseClient | null,
+    user: User | null,
+    session: Session | null,
     idleTimeoutMs?: number,
     warnBeforeMs?: number,
     onIdleLogout?: (reason: 'inactivity') => void
@@ -169,7 +182,7 @@ export class InactivityService extends BaseService implements IInactivityService
       if (this.supabaseClient) {
         await this.supabaseClient.auth.signOut();
       }
-    } catch (error: any) {
+    } catch (error) {
       logger.error('InactivityService', 'Error during idle logout:', error);
     }
     
@@ -195,7 +208,7 @@ export class InactivityService extends BaseService implements IInactivityService
       if (this.supabaseClient) {
         await this.supabaseClient.auth.signOut();
       }
-    } catch (error: any) {
+    } catch (error) {
       logger.error('InactivityService', 'Error during manual sign out:', error);
     }
     
@@ -211,8 +224,11 @@ export class InactivityService extends BaseService implements IInactivityService
   }
 
   cleanup(): void {
+    if (this.cleanupHandlers) {
+      this.cleanupHandlers();
+      this.cleanupHandlers = null;
+    }
     if (this.inactivityTracker) {
-      this.inactivityTracker.cleanup?.();
       this.inactivityTracker = null;
     }
     this._isTracking = false;
@@ -243,50 +259,14 @@ export class InactivityService extends BaseService implements IInactivityService
     if (typeof window === 'undefined') return;
 
     // Check if inactivity is enabled
-    this.isInactivityEnabled = this.user && this.session;
+    this.isInactivityEnabled = !!(this.user && this.session);
 
     if (!this.isInactivityEnabled) {
       return;
     }
 
-    try {
-      // Dynamically import the inactivity tracker hook
-      const { useInactivityTracker } = await import('../hooks/useInactivityTracker');
-      
-      // Create a mock implementation since we can't use hooks in services
-      // In a real implementation, you'd need to create a non-hook version
-      this.inactivityTracker = {
-        isIdle: false,
-        timeRemaining: 0,
-        showWarning: false,
-        isTracking: false,
-        resetActivity: () => {
-          this._isIdle = false;
-          this._timeRemaining = 0;
-          this._showWarning = false;
-          this.notify();
-        },
-        startTracking: () => {
-          this._isTracking = true;
-          this.notify();
-        },
-        stopTracking: () => {
-          this._isTracking = false;
-          this.notify();
-        },
-        cleanup: () => {
-          this._isTracking = false;
-          this._isIdle = false;
-          this._showWarning = false;
-          this._timeRemaining = 0;
-        }
-      };
-
-      // Set up event handlers
-      this.setupEventHandlers();
-    } catch (error) {
-      logger.error('InactivityService', 'Failed to setup inactivity tracker:', error);
-    }
+    // Set up event handlers directly (no need to import hooks - services are pure TypeScript)
+    this.setupEventHandlers();
   }
 
   private setupEventHandlers(): void {
@@ -360,7 +340,7 @@ export class InactivityService extends BaseService implements IInactivityService
     startIdleTimer();
 
     // Store cleanup function
-    this.inactivityTracker.cleanup = () => {
+    this.cleanupHandlers = () => {
       if (idleTimer) {
         clearTimeout(idleTimer);
         idleTimer = null;