refactor(backend): improve token cleanup service logging and initialization

Author: Lasim

services/backend/src/index.ts

@@ -1,6 +1,5 @@
 import { createServer } from './server'
 import { displayStartupBanner } from './utils/banner'
-import { TokenCleanupService } from './services/tokenCleanupService'
 
 const start = async () => {
   try {
@@ -13,9 +12,6 @@ const start = async () => {
     // Display the fancy startup banner
     displayStartupBanner(port, server.log)
 
-    // Start background services
-    TokenCleanupService.start()
-    
     // Also log using the standard logger (useful for log files)
     server.log.info(`DeployStack server started on port ${port}`)
   } catch (err) {

services/backend/src/routes/satellites/registration-tokens.ts

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import { type FastifyInstance } from 'fastify';
 import { SatelliteTokenService } from '../../services/satelliteTokenService';
 import { requireGlobalAdmin, requireTeamPermission, requireAuthentication } from '../../middleware/roleMiddleware';
@@ -208,7 +209,7 @@ export default async function registrationTokenRoutes(server: FastifyInstance) {
         error: 'Failed to generate registration token'
       };
       const jsonString = JSON.stringify(errorResponse);
-      return reply.status(500).type('application/json').send(jsonString);
+      return reply.status(500 as any).type('application/json').send(jsonString);
     }
   });
 
@@ -303,7 +304,7 @@ export default async function registrationTokenRoutes(server: FastifyInstance) {
         error: 'Failed to generate registration token'
       };
       const jsonString = JSON.stringify(errorResponse);
-      return reply.status(500).type('application/json').send(jsonString);
+      return reply.status(500 as any).type('application/json').send(jsonString);
     }
   });
 
@@ -346,7 +347,7 @@ export default async function registrationTokenRoutes(server: FastifyInstance) {
         error: 'Failed to list tokens' 
       };
       const jsonString = JSON.stringify(errorResponse);
-      return reply.status(500).type('application/json').send(jsonString);
+      return reply.status(500 as any).type('application/json').send(jsonString);
     }
   });
 
@@ -399,7 +400,7 @@ export default async function registrationTokenRoutes(server: FastifyInstance) {
         error: 'Failed to list tokens' 
       };
       const jsonString = JSON.stringify(errorResponse);
-      return reply.status(500).type('application/json').send(jsonString);
+      return reply.status(500 as any).type('application/json').send(jsonString);
     }
   });
 
@@ -482,7 +483,7 @@ export default async function registrationTokenRoutes(server: FastifyInstance) {
         error: 'Failed to revoke token' 
       };
       const jsonString = JSON.stringify(errorResponse);
-      return reply.status(500).type('application/json').send(jsonString);
+      return reply.status(500 as any).type('application/json').send(jsonString);
     }
   });
 }

services/backend/src/server.ts

@@ -151,9 +151,25 @@ export async function initializeDatabaseDependentServices(
         server.log.warn('⚠️ Continuing without MCP User Configuration Service due to error');
       }
 
+      // Start Token Cleanup Service (only after database is ready)
+      try {
+        server.log.debug('Starting Token Cleanup Service...');
+        const { TokenCleanupService } = await import('./services/tokenCleanupService');
+        TokenCleanupService.start(server.log);
+        server.log.debug('Token Cleanup Service started');
+      } catch (tokenCleanupError) {
+        server.log.error({
+          error: tokenCleanupError,
+          message: tokenCleanupError instanceof Error ? tokenCleanupError.message : 'Unknown error',
+          stack: tokenCleanupError instanceof Error ? tokenCleanupError.stack : 'No stack trace'
+        }, 'Token Cleanup Service failed to start:');
+        // Don't throw - continue with startup but log the error
+        server.log.warn('Continuing without Token Cleanup Service due to error');
+      }
+
       // Initialize global settings with comprehensive debugging
       try {
-        server.log.debug('🔄 Starting global settings initialization...');
+        server.log.debug('Starting global settings initialization...');
 
         // Check database status before proceeding
         const dbStatus = getDbStatus();

services/backend/src/services/satelliteTokenService.ts

@@ -1,7 +1,7 @@
 import { nanoid } from 'nanoid';
 import { hash, verify } from '@node-rs/argon2';
 import { getDb } from '../db';
-import { satelliteRegistrationTokens, teams, authUser } from '../db/schema.sqlite';
+import { satelliteRegistrationTokens } from '../db/schema.sqlite';
 import { eq, and, lt } from 'drizzle-orm';
 import { SimpleJWT, TokenExpiredError } from '../utils/jwt';
 import type { 
@@ -115,6 +115,7 @@ export class SatelliteTokenService {
       try {
         payload = SimpleJWT.verify(jwtToken, this.JWT_SECRET) as JWTPayload;
       } catch (jwtError) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         if (jwtError instanceof TokenExpiredError || (jwtError as any).name === 'TokenExpiredError') {
           return { valid: false, error: 'Token has expired' };
         }

services/backend/src/services/tokenCleanupService.ts

@@ -1,4 +1,5 @@
 import { SatelliteTokenService } from './satelliteTokenService';
+import type { FastifyBaseLogger } from 'fastify';
 
 /**
  * Background service for cleaning up expired satellite registration tokens
@@ -7,33 +8,49 @@ import { SatelliteTokenService } from './satelliteTokenService';
 export class TokenCleanupService {
   private static intervalId: NodeJS.Timeout | null = null;
   private static readonly DEFAULT_CLEANUP_INTERVAL_MS = 60 * 60 * 1000; // 1 hour
+  private static logger: FastifyBaseLogger | null = null;
 
   /**
    * Start periodic cleanup of expired tokens
    * Runs every hour by default
    */
-  static start(intervalMs: number = this.DEFAULT_CLEANUP_INTERVAL_MS) {
+  static start(logger: FastifyBaseLogger, intervalMs: number = this.DEFAULT_CLEANUP_INTERVAL_MS) {
     if (this.intervalId) {
-      console.log('🧹 Token cleanup service already running');
+      logger.warn({
+        operation: 'token_cleanup_start',
+        status: 'already_running'
+      }, '🧹 Token cleanup service already running');
       return;
     }
 
+    this.logger = logger;
+
     // Run cleanup immediately on start
     this.runCleanup().catch(error => {
-      console.error('Initial token cleanup failed:', error);
+      logger.error({
+        operation: 'token_cleanup_initial',
+        error
+      }, 'Initial token cleanup failed');
     });
 
     // Schedule periodic cleanup
     this.intervalId = setInterval(async () => {
       try {
         await this.runCleanup();
       } catch (error) {
-        console.error('Token cleanup failed:', error);
+        logger.error({
+          operation: 'token_cleanup_periodic',
+          error
+        }, 'Token cleanup failed');
       }
     }, intervalMs);
 
     const intervalHours = Math.round(intervalMs / (60 * 60 * 1000));
-    console.log(`🕒 Token cleanup service started (runs every ${intervalHours} hour${intervalHours !== 1 ? 's' : ''})`);
+    logger.info({
+      operation: 'token_cleanup_start',
+      intervalMs,
+      intervalHours
+    }, `🕒 Token cleanup service started (runs every ${intervalHours} hour${intervalHours !== 1 ? 's' : ''})`);
   }
 
   /**
@@ -43,7 +60,12 @@ export class TokenCleanupService {
     if (this.intervalId) {
       clearInterval(this.intervalId);
       this.intervalId = null;
-      console.log('🛑 Token cleanup service stopped');
+      
+      if (this.logger) {
+        this.logger.info({
+          operation: 'token_cleanup_stop'
+        }, '🛑 Token cleanup service stopped');
+      }
     }
   }
 
@@ -53,12 +75,20 @@ export class TokenCleanupService {
   static async runCleanup(): Promise<number> {
     try {
       const deletedCount = await SatelliteTokenService.cleanupExpiredTokens();
-      if (deletedCount > 0) {
-        console.log(`🧹 Cleaned up ${deletedCount} expired satellite registration token${deletedCount !== 1 ? 's' : ''}`);
+      if (deletedCount > 0 && this.logger) {
+        this.logger.info({
+          operation: 'token_cleanup_run',
+          deletedCount
+        }, `🧹 Cleaned up ${deletedCount} expired satellite registration token${deletedCount !== 1 ? 's' : ''}`);
       }
       return deletedCount;
     } catch (error) {
-      console.error('Token cleanup failed:', error);
+      if (this.logger) {
+        this.logger.error({
+          operation: 'token_cleanup_run',
+          error
+        }, 'Token cleanup failed');
+      }
       throw error;
     }
   }
@@ -76,8 +106,8 @@ export class TokenCleanupService {
   /**
    * Restart the cleanup service with new interval
    */
-  static restart(intervalMs?: number) {
+  static restart(logger: FastifyBaseLogger, intervalMs?: number) {
     this.stop();
-    this.start(intervalMs);
+    this.start(logger, intervalMs);
   }
 }

services/backend/src/utils/jwt.ts

@@ -1,4 +1,5 @@
-import { createHmac, randomBytes, timingSafeEqual } from 'crypto';
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { createHmac, timingSafeEqual } from 'crypto';
 
 /**
  * Simple JWT implementation using Node.js crypto