@memberjunction/server 2.106.0 → 2.108.0

package/src/index.ts

@@ -40,6 +40,12 @@ LoadCoreEntitiesServerSubClasses(); // prevent tree shaking for this dynamic mod
 import { LoadAgentManagementActions } from '@memberjunction/ai-agent-manager-actions';
 LoadAgentManagementActions();
 
+import { LoadSchedulingEngine } from '@memberjunction/scheduling-engine';
+LoadSchedulingEngine(); // This also loads drivers
+
+import { LoadAllSchedulingActions } from '@memberjunction/scheduling-actions';
+LoadAllSchedulingActions(); // prevent tree shaking for scheduling actions
+
 
 import { resolve } from 'node:path';
 import { DataSourceInfo, raiseEvent } from './types.js';
@@ -50,6 +56,7 @@ LoadAIEngine();
 LoadAIProviders();
 
 import { ExternalChangeDetectorEngine } from '@memberjunction/external-change-detection';
+import { ScheduledJobsService } from './services/ScheduledJobsService.js';
 
 const cacheRefreshInterval = configInfo.databaseSettings.metadataCacheRefreshInterval;
 
@@ -302,6 +309,19 @@ export const serve = async (resolverPaths: Array<string>, app = createApp(), opt
   // Set up REST endpoints with the configured options and auth middleware
   setupRESTEndpoints(app, restApiConfig, authMiddleware);
 
+  // Initialize and start scheduled jobs service if enabled
+  let scheduledJobsService: ScheduledJobsService | null = null;
+  if (configInfo.scheduledJobs?.enabled) {
+    try {
+      scheduledJobsService = new ScheduledJobsService(configInfo.scheduledJobs);
+      await scheduledJobsService.Initialize();
+      await scheduledJobsService.Start();
+    } catch (error) {
+      console.error('❌ Failed to start scheduled jobs service:', error);
+      // Don't throw - allow server to start even if scheduled jobs fail
+    }
+  }
+
   if (options?.onBeforeServe) {
     await Promise.resolve(options.onBeforeServe());
   }
@@ -309,4 +329,34 @@ export const serve = async (resolverPaths: Array<string>, app = createApp(), opt
   await new Promise<void>((resolve) => httpServer.listen({ port: graphqlPort }, resolve));
   console.log(`📦 Connected to database: ${dbHost}:${dbPort}/${dbDatabase}`);
   console.log(`🚀 Server ready at http://localhost:${graphqlPort}/`);
+
+  // Set up graceful shutdown handlers
+  const gracefulShutdown = async (signal: string) => {
+    console.log(`\n${signal} received, shutting down gracefully...`);
+
+    // Stop scheduled jobs service
+    if (scheduledJobsService?.IsRunning) {
+      try {
+        await scheduledJobsService.Stop();
+        console.log('✅ Scheduled jobs service stopped');
+      } catch (error) {
+        console.error('❌ Error stopping scheduled jobs service:', error);
+      }
+    }
+
+    // Close server
+    httpServer.close(() => {
+      console.log('✅ HTTP server closed');
+      process.exit(0);
+    });
+
+    // Force close after 10 seconds
+    setTimeout(() => {
+      console.error('⚠️  Forced shutdown after timeout');
+      process.exit(1);
+    }, 10000);
+  };
+
+  process.on('SIGTERM', () => gracefulShutdown('SIGTERM'));
+  process.on('SIGINT', () => gracefulShutdown('SIGINT'));
 };

package/src/resolvers/AskSkipResolver.ts

@@ -375,7 +375,8 @@ function initializeSkipLearningCycleScheduler() {
             return;
           }
           if (!skipConfigInfo.learningCycleEnabled) {
-            LogStatus('Skip AI Learning Cycles not enabled in configuration');
+            // Skip AI Learning Cycles not enabled - disabled logging to reduce startup noise
+            // LogStatus('Skip AI Learning Cycles not enabled in configuration');
             return;
           }
           
@@ -428,8 +429,9 @@ function initializeSkipLearningCycleScheduler() {
     LogError(`Failed to initialize Skip learning cycle scheduler: ${error}`);
   }
 }
-// now call the function to initialize the scheduler
-initializeSkipLearningCycleScheduler();
+// Disabled: Skip AI Learning Cycles no longer used - commented out to prevent startup initialization
+// If needed in the future, uncomment the line below:
+// initializeSkipLearningCycleScheduler();
 
 /**
  * Base type for Skip API requests containing common fields

package/src/resolvers/RunAIAgentResolver.ts

@@ -136,6 +136,7 @@ export class RunAIAgentResolver extends ResolverBase {
         const sanitized: any = {
             success: result.success,
             payload: result.payload,
+            suggestedResponses: result.suggestedResponses,
             errorMessage: result.agentRun?.ErrorMessage,
             finalStep: result.agentRun?.FinalStep,
             cancelled: result.agentRun?.Status === 'Cancelled',

package/src/services/ScheduledJobsService.ts

@@ -0,0 +1,164 @@
+/**
+ * @fileoverview Service module for managing scheduled job lifecycle
+ * @module MJServer/services
+ */
+
+import { LogError, LogStatus, UserInfo } from '@memberjunction/core';
+import { UserCache } from '@memberjunction/sqlserver-dataprovider';
+import { SchedulingEngine } from '@memberjunction/scheduling-engine';
+import { ScheduledJobsConfig } from '../config.js';
+
+/**
+ * Service for managing scheduled jobs lifecycle
+ * Handles initialization, starting/stopping polling, and graceful shutdown
+ */
+export class ScheduledJobsService {
+    private engine: SchedulingEngine;
+    private systemUser: UserInfo | null = null;
+    private isRunning: boolean = false;
+    private config: ScheduledJobsConfig;
+
+    constructor(config: ScheduledJobsConfig) {
+        this.config = config;
+        this.engine = SchedulingEngine.Instance;
+    }
+
+    /**
+     * Initialize the scheduled jobs service
+     * Loads metadata and prepares the engine
+     */
+    public async Initialize(): Promise<void> {
+        if (!this.config.enabled) {
+            LogStatus('[ScheduledJobsService] Scheduled jobs are disabled in configuration');
+            return;
+        }
+
+        try {
+            // Get system user for job execution
+            this.systemUser = await this.getSystemUser();
+
+            if (!this.systemUser) {
+                throw new Error(`System user not found with email: ${this.config.systemUserEmail}`);
+            }
+
+            // Pre-load metadata cache
+            await this.engine.Config(false, this.systemUser);
+        } catch (error) {
+            LogError('[ScheduledJobsService] Failed to initialize', undefined, error);
+            throw error;
+        }
+    }
+
+    /**
+     * Start the scheduled jobs polling
+     */
+    public async Start(): Promise<void> {
+        if (!this.config.enabled) {
+            return;
+        }
+
+        if (this.isRunning) {
+            LogStatus('[ScheduledJobsService] Already running');
+            return;
+        }
+
+        if (!this.systemUser) {
+            throw new Error('Service not initialized - call Initialize() first');
+        }
+
+        try {
+            this.engine.StartPolling(this.systemUser);
+            this.isRunning = true;
+
+            // Single consolidated console message
+            const jobCount = this.engine.ScheduledJobs.length;
+            if (jobCount === 0) {
+                console.log(`📅 Scheduled Jobs: No active jobs, polling suspended (will auto-start when jobs are added)`);
+            } else {
+                const interval = this.engine.ActivePollingInterval;
+                if (interval !== null) {
+                    const intervalDisplay = interval >= 60000
+                        ? `${Math.round(interval / 60000)} minute(s)`
+                        : `${Math.round(interval / 1000)} second(s)`;
+                    console.log(`📅 Scheduled Jobs: ${jobCount} active job(s), polling every ${intervalDisplay}`);
+                } else {
+                    // This shouldn't happen if jobCount > 0, but handle it gracefully
+                    console.log(`📅 Scheduled Jobs: ${jobCount} active job(s), polling interval not set`);
+                }
+            }
+        } catch (error) {
+            LogError('[ScheduledJobsService] Failed to start polling', undefined, error);
+            throw error;
+        }
+    }
+
+    /**
+     * Stop the scheduled jobs polling gracefully
+     */
+    public async Stop(): Promise<void> {
+        if (!this.isRunning) {
+            return;
+        }
+
+        try {
+            LogStatus('[ScheduledJobsService] Stopping scheduled job polling');
+            this.engine.StopPolling();
+            this.isRunning = false;
+            LogStatus('[ScheduledJobsService] Polling stopped successfully');
+        } catch (error) {
+            LogError('[ScheduledJobsService] Error stopping polling', undefined, error);
+            throw error;
+        }
+    }
+
+    /**
+     * Get the system user for job execution
+     * Uses the email configured in scheduledJobs.systemUserEmail
+     */
+    private async getSystemUser(): Promise<UserInfo | null> {
+        const systemUserEmail = this.config.systemUserEmail;
+
+        // Search UserCache for system user
+        const user = UserCache.Users.find(u =>
+            u.Email?.toLowerCase() === systemUserEmail.toLowerCase()
+        );
+
+        if (user) {
+            return user;
+        }
+
+        LogError(`[ScheduledJobsService] System user not found with email: ${systemUserEmail}`);
+        return null;
+    }
+
+    /**
+     * Get current service status
+     */
+    public GetStatus(): {
+        enabled: boolean;
+        running: boolean;
+        activeJobs: number;
+        pollingInterval: number;
+    } {
+        return {
+            enabled: this.config.enabled,
+            running: this.isRunning,
+            activeJobs: this.engine?.ScheduledJobs?.length || 0,
+            pollingInterval: this.engine?.ActivePollingInterval || 0
+        };
+    }
+
+    /**
+     * Check if service is enabled in configuration
+     */
+    public get IsEnabled(): boolean {
+        return this.config.enabled;
+    }
+
+    /**
+     * Check if service is currently running
+     */
+    public get IsRunning(): boolean {
+        return this.isRunning;
+    }
+}