style(frontend): reorder source filter tabs and bulk actions toolbar

feat(frontend): add source filter for MCP server catalog
feat(backend): add source filter for MCP server listing and queries
feat(frontend): implement bulk delete functionality for MCP servers
feat(backend): add bulk delete functionality for global MCP servers
feat(frontend): implement server deletion functionality with confirmation dialog
feat(frontend): add enable/disable functionality for MCP servers
feat(backend): add 'disabled' status to MCP server management
feat(backend): enhance cron job management with immediate job creation
feat(backend): add support for 'disabled' status in MCP server management
feat(frontend): enhance configuration schema handling in forms
refactor(frontend): improve remote and package validation logic

Author: Lasim

services/backend/api-spec.json

@@ -1,71 +1,112 @@
 import * as cron from 'node-cron';
 import type { FastifyBaseLogger } from 'fastify';
+import type { JobQueueService } from '../services/jobQueueService';
 
 /**
  * CronJob interface - each cron job file must export this structure
+ *
+ * The CronManager will automatically create a job in the queue when the cron fires.
+ * This ensures job records exist immediately for visibility in the admin panel,
+ * even if something fails during job creation or execution.
  */
 export interface CronJob {
   /** Cron schedule expression (e.g., every 2 minutes, hourly, daily) */
   schedule: string;
-  
-  /** Optional job name for logging */
-  name?: string;
-  
-  /** The task function to execute */
-  task: () => void | Promise<void>;
+
+  /** Job name for logging and identification (required) */
+  name: string;
+
+  /** The job type that will be created in the queue (must match a registered worker) */
+  jobType: string;
+
+  /**
+   * Payload to pass to the worker. Can be a static object or a function that returns an object.
+   * Use a function when payload needs to be computed at cron fire time.
+   */
+  payload?: Record<string, unknown> | (() => Record<string, unknown>);
+
+  /** Maximum retry attempts for this job (default: 3) */
+  maxAttempts?: number;
 }
 
 /**
  * CronManager - Manages all cron jobs in the application
- * 
+ *
  * This class discovers, registers, and manages all cron jobs.
  * It provides lifecycle management including graceful shutdown.
+ *
+ * Key design: When a cron schedule fires, the CronManager immediately creates
+ * a job record in the database queue. This ensures visibility in the admin panel
+ * even if something fails during job creation or worker execution.
  */
 export class CronManager {
   private jobs: Map<string, cron.ScheduledTask> = new Map();
-  private logger: FastifyBaseLogger;
+  private readonly logger: FastifyBaseLogger;
+  private readonly jobQueueService: JobQueueService;
 
-  constructor(logger: FastifyBaseLogger) {
+  constructor(logger: FastifyBaseLogger, jobQueueService: JobQueueService) {
     this.logger = logger;
+    this.jobQueueService = jobQueueService;
   }
 
   /**
    * Register a new cron job
-   * 
+   *
+   * When the cron schedule fires, this method immediately creates a job record
+   * in the database queue. The job is then processed by the JobProcessorService.
+   *
    * @param jobDefinition - The cron job definition
    */
   register(jobDefinition: CronJob): void {
-    const jobName = jobDefinition.name || 'unnamed-job';
+    const { name: jobName, schedule, jobType, payload, maxAttempts } = jobDefinition;
 
     try {
-      const task = cron.schedule(jobDefinition.schedule, async () => {
-        this.logger.info({ 
-          job: jobName, 
-          schedule: jobDefinition.schedule 
-        }, 'Executing cron job');
+      const task = cron.schedule(schedule, async () => {
+        this.logger.info({
+          job: jobName,
+          jobType,
+          schedule,
+        }, 'Cron triggered, creating job in queue');
 
         try {
-          await jobDefinition.task();
-          this.logger.debug({ job: jobName }, 'Cron job completed successfully');
+          // Calculate payload - can be static object or function
+          const resolvedPayload = typeof payload === 'function'
+            ? payload()
+            : payload ?? {};
+
+          // Create job in queue immediately - this is the key change
+          const job = await this.jobQueueService.createJob(
+            jobType,
+            resolvedPayload,
+            maxAttempts ? { maxAttempts } : undefined
+          );
+
+          this.logger.info({
+            job: jobName,
+            jobId: job.id,
+            jobType,
+          }, 'Cron job queued successfully');
         } catch (error) {
-          this.logger.error({ 
-            job: jobName, 
-            error 
-          }, 'Cron job execution failed');
+          this.logger.error({
+            job: jobName,
+            jobType,
+            error,
+          }, 'Failed to queue cron job');
         }
       });
 
       this.jobs.set(jobName, task);
-      this.logger.info({ 
-        job: jobName, 
-        schedule: jobDefinition.schedule 
+      this.logger.info({
+        job: jobName,
+        jobType,
+        schedule,
       }, 'Cron job registered');
-
     } catch (error) {
-      this.logger.error({ 
-        job: jobName, 
-        schedule: jobDefinition.schedule, 
-        error 
+      this.logger.error({
+        job: jobName,
+        jobType,
+        schedule,
+        error,
       }, 'Failed to register cron job');
     }
   }

services/backend/api-spec.yaml

@@ -9,13 +9,17 @@ import { createCleanupSatelliteHeartbeatsJob } from './jobs/cleanupSatelliteHear
 
 /**
  * Initialize and register all cron jobs
- * 
+ *
  * This function is called during server startup to set up all cron jobs.
  * Add new cron jobs by:
  * 1. Creating a job file in the jobs/ directory
  * 2. Importing it here
  * 3. Registering it with the CronManager
- * 
+ *
+ * The CronManager handles job creation automatically when cron schedules fire.
+ * Each cron job definition specifies the jobType and payload, and the CronManager
+ * creates the job record in the queue immediately.
+ *
  * @param jobQueueService - Job queue service for creating background jobs
  * @param logger - Logger instance
  * @returns CronManager instance
@@ -24,27 +28,27 @@ export function initializeCronJobs(
   jobQueueService: JobQueueService,
   logger: FastifyBaseLogger
 ): CronManager {
-  const cronManager = new CronManager(logger);
+  const cronManager = new CronManager(logger, jobQueueService);
 
   // MCP client activity metrics cleanup (every 30 minutes)
-  cronManager.register(createMcpClientActivityMetricsCleanupJob(jobQueueService));
+  cronManager.register(createMcpClientActivityMetricsCleanupJob());
 
   // Cleanup old queue jobs (every 6 hours)
-  cronManager.register(createCleanupOldJobsJob(jobQueueService));
+  cronManager.register(createCleanupOldJobsJob());
 
   // Refresh expiring OAuth tokens for MCP servers (every 5 minutes)
-  cronManager.register(createRefreshOAuthTokensJob(jobQueueService));
+  cronManager.register(createRefreshOAuthTokensJob());
 
   // Cleanup satellite heartbeats (every 3 minutes)
-  cronManager.register(createCleanupSatelliteHeartbeatsJob(jobQueueService));
+  cronManager.register(createCleanupSatelliteHeartbeatsJob());
 
   // Example cron job - commented out, uncomment to test
-  // cronManager.register(createExampleCronJob(jobQueueService));
+  // cronManager.register(createExampleCronJob());
 
   // Add your cron jobs here
   // Example:
-  // cronManager.register(createDailyBackupJob(jobQueueService));
-  // cronManager.register(createHourlyCleanupJob(jobQueueService));
+  // cronManager.register(createDailyBackupJob());
+  // cronManager.register(createHourlyCleanupJob());
 
   return cronManager;
 }

services/backend/src/cron/cronManager.ts

@@ -1,15 +1,21 @@
 import type { CronJob } from '../cronManager';
-import type { JobQueueService } from '../../services/jobQueueService';
 
-export function createCleanupOldJobsJob(jobQueueService: JobQueueService): CronJob {
+/**
+ * Cleanup Old Jobs Cron Job
+ *
+ * Runs every 6 hours to clean up old completed/failed jobs from the queue.
+ *
+ * Schedule: Every 6 hours
+ * Job Type: cleanup_old_jobs
+ * Retention: 14 days
+ */
+export function createCleanupOldJobsJob(): CronJob {
   return {
     name: 'cleanup-old-jobs',
-    schedule: '0 */6 * * *', // Every 6 hours
-    
-    task: async () => {
-      await jobQueueService.createJob('cleanup_old_jobs', {
-        olderThanDays: 14
-      });
-    }
+    schedule: '0 */6 * * *',
+    jobType: 'cleanup_old_jobs',
+    payload: {
+      olderThanDays: 14,
+    },
   };
 }

services/backend/src/cron/index.ts

@@ -1,13 +1,12 @@
 import type { CronJob } from '../cronManager';
-import type { JobQueueService } from '../../services/jobQueueService';
 
 /**
  * Satellite Heartbeat Cleanup Cron Job
  *
  * Runs every 3 minutes to clean up old satellite heartbeat records.
  * Different retention limits apply based on satellite type:
  * - Global satellites: 1000 records (shared infrastructure, more aggressive cleanup)
- * - Team satellites: 500 records (dedicated infrastructure, shorter retention due to fewer satellites)
+ * - Team satellites: 500 records (dedicated infrastructure, shorter retention)
  *
  * This cleanup was moved out of the heartbeat route to prevent
  * blocking the main event loop with expensive window function queries,
@@ -16,16 +15,14 @@ import type { JobQueueService } from '../../services/jobQueueService';
  * Schedule: Every 3 minutes
  * Job Type: cleanup_satellite_heartbeats
  */
-export function createCleanupSatelliteHeartbeatsJob(jobQueueService: JobQueueService): CronJob {
-	return {
-		name: 'cleanup-satellite-heartbeats',
-		schedule: '*/3 * * * *', // Every 3 minutes
-
-		task: async () => {
-			await jobQueueService.createJob('cleanup_satellite_heartbeats', {
-				globalSatelliteLimit: 1000,
-				teamSatelliteLimit: 500,
-			});
-		},
-	};
+export function createCleanupSatelliteHeartbeatsJob(): CronJob {
+  return {
+    name: 'cleanup-satellite-heartbeats',
+    schedule: '*/3 * * * *',
+    jobType: 'cleanup_satellite_heartbeats',
+    payload: {
+      globalSatelliteLimit: 1000,
+      teamSatelliteLimit: 500,
+    },
+  };
 }

services/backend/src/cron/jobs/cleanupOldJobs.ts

@@ -1,24 +1,25 @@
 import type { CronJob } from '../cronManager';
-import type { JobQueueService } from '../../services/jobQueueService';
 
 /**
  * Example Cron Job - Runs every 2 minutes
- * 
- * This job demonstrates how to push work to the job queue system
- * from a cron schedule. Every 2 minutes, it creates a new job in
- * the queue which will be processed by the ExampleCronWorker.
- * 
+ *
+ * This job demonstrates how to define a cron job that creates work
+ * in the job queue system. Every 2 minutes, a job is created
+ * which will be processed by the ExampleCronWorker.
+ *
  * The worker will log: "hello from queue every 2min"
+ *
+ * To use this example:
+ * 1. Uncomment the import and registration in cron/index.ts
+ * 2. Uncomment the worker registration in workers/index.ts
  */
-export function createExampleCronJob(jobQueueService: JobQueueService): CronJob {
+export function createExampleCronJob(): CronJob {
   return {
     name: 'example-every-2min',
-    schedule: '*/2 * * * *', // Every 2 minutes
-    
-    task: async () => {
-      await jobQueueService.createJob('example_cron_job', {
-        message: 'hello from queue every 2min'
-      });
-    }
+    schedule: '*/2 * * * *',
+    jobType: 'example_cron_job',
+    payload: {
+      message: 'hello from queue every 2min',
+    },
   };
 }

services/backend/src/cron/jobs/cleanupSatelliteHeartbeats.ts

@@ -1,30 +1,22 @@
 import type { CronJob } from '../cronManager';
-import type { JobQueueService } from '../../services/jobQueueService';
 
 /**
  * MCP Client Activity Metrics Cleanup Cron Job
- * 
+ *
  * Runs every 30 minutes to clean up old MCP client activity metrics data.
- * 
- * This job creates a background job in the queue that will delete all
- * metric buckets from the mcpClientActivityMetrics table that are older
- * than 3 days (hardcoded retention period).
- * 
- * Schedule: Every 30 minutes (*\/30 * * * *)
+ *
+ * This job deletes all metric buckets from the mcpClientActivityMetrics table
+ * that are older than 3 days (hardcoded retention period in worker).
+ *
+ * Schedule: Every 30 minutes
  * Job Type: cleanup_mcp_client_activity_metrics
- * Retention: 3 days (hardcoded)
+ * Retention: 3 days (hardcoded in worker)
  */
-export function createMcpClientActivityMetricsCleanupJob(
-  jobQueueService: JobQueueService
-): CronJob {
+export function createMcpClientActivityMetricsCleanupJob(): CronJob {
   return {
     name: 'mcp-client-activity-metrics-cleanup',
-    schedule: '*/30 * * * *', // Every 30 minutes
-    
-    task: async () => {
-      // Create cleanup job in queue
-      // Empty payload - retention period is hardcoded to 3 days in worker
-      await jobQueueService.createJob('cleanup_mcp_client_activity_metrics', {});
-    }
+    schedule: '*/30 * * * *',
+    jobType: 'cleanup_mcp_client_activity_metrics',
+    // Empty payload - retention period is hardcoded in worker
   };
 }

services/backend/src/cron/jobs/exampleJob.ts

@@ -1,29 +1,24 @@
 import type { CronJob } from '../cronManager';
-import type { JobQueueService } from '../../services/jobQueueService';
 
 /**
  * OAuth Token Refresh Cron Job
  *
  * Runs every 5 minutes to refresh expiring OAuth tokens for MCP servers.
  *
- * This job creates a background job in the queue that will:
+ * The worker will:
  * - Find tokens expiring within next 10 minutes
  * - Refresh them using their refresh_token
  * - Update encrypted tokens in database
  *
- * Schedule: Every 5 minutes (*\/5 * * * *)
+ * Schedule: Every 5 minutes
  * Job Type: refresh_oauth_tokens
  * Threshold: 10 minutes before expiry
  */
-export function createRefreshOAuthTokensJob(jobQueueService: JobQueueService): CronJob {
-	return {
-		name: 'refresh-oauth-tokens',
-		schedule: '*/5 * * * *', // Every 5 minutes
-
-		task: async () => {
-			// Create refresh job in queue
-			// Worker will call refreshExpiringOAuthTokens() to process
-			await jobQueueService.createJob('refresh_oauth_tokens', {});
-		},
-	};
+export function createRefreshOAuthTokensJob(): CronJob {
+  return {
+    name: 'refresh-oauth-tokens',
+    schedule: '*/5 * * * *',
+    jobType: 'refresh_oauth_tokens',
+    // Empty payload - worker handles token discovery
+  };
 }