Optimizely DXP MCP Server

Instructions

Implementation Reference

• lib/tools/monitoring-tools.ts:336-375 (handler)

  The handler function that implements the 'list_monitors' tool logic. It reads active monitors from DatabaseSimpleTools.backgroundMonitors and formats a Markdown response with status and available commands.

  static async listMonitors(_params: MonitoringParams = {}): Promise<any> {
      try {
          // Check for active database export monitors
          const DatabaseSimpleTools = require('./database-simple-tools');
          const activeMonitors: Map<string, BackgroundMonitor> = DatabaseSimpleTools.backgroundMonitors;
  
          const response: string[] = [];
          response.push('## 📡 Deployment Monitoring Status\n');
  
          if (activeMonitors && activeMonitors.size > 0) {
              response.push(`**Active Monitors:** ${activeMonitors.size} background monitor(s) running`);
              for (const [exportId, monitor] of activeMonitors) {
                  const runtime = Math.round((Date.now() - monitor.startTime) / 60000);
                  // Show 13 chars to get past first dash (e.g., "c88fa98f-9d3c...")
                  response.push(`• Database Export: ${exportId.substring(0, 13)}... (${monitor.environment}/${monitor.databaseName}) - ${runtime}m`);
              }
          } else {
              response.push('**Active Monitors:** Currently no background monitors running');
          }
          response.push('**Monitoring Features:**');
          response.push('• Real-time deployment tracking');
          response.push('• Progress monitoring with ETA calculation');
          response.push('• Automatic completion detection');
          response.push('• Background monitoring support\n');
  
          response.push('**Available Commands:**');
          response.push('• `update_monitoring_interval` - Change monitoring frequency');
          response.push('• `stop_monitoring` - Stop active monitors');
          response.push('• `get_monitoring_stats` - View detailed statistics\n');
  
          response.push('💡 **Tip:** Monitoring is automatically started when using deployment tools');
  
          return ResponseBuilder.success(
              response.join('\n')
          );
  
      } catch (error: any) {
          return ErrorHandler.handleError(error, { operation: 'list_monitors' });
      }
  }

• lib/tools/database-simple-tools.ts:270-270 (helper)

  Static Map storing active background monitors (exportId -> BackgroundMonitor), which is accessed by listMonitors handler.

  static backgroundMonitors = new Map<string, BackgroundMonitor>();

• lib/tools/database-simple-tools.ts:1340-1447 (helper)

  Helper function that starts and manages background monitoring for database exports, populating the backgroundMonitors map used by list_monitors.

  static startBackgroundMonitoring(
      exportId: string,
      projectConfig: ProjectConfig,
      environment: string,
      databaseName: string,
      downloadPath?: string
  ): void {
      // Check if already monitoring this export
      if (this.backgroundMonitors.has(exportId)) {
          OutputLogger.info(`Already monitoring export ${exportId}`);
          return;
      }
  
      const monitorData: MonitorData = {
          exportId,
          projectConfig,
          environment,
          databaseName,
          downloadPath,
          startedAt: new Date().toISOString(),
          pollCount: 0
      };
  
      const emitter = new EventEmitter() as BackgroundMonitor;
      emitter.exportId = exportId;
      emitter.data = monitorData;
  
      this.backgroundMonitors.set(exportId, emitter);
  
      // Start monitoring loop
      const pollInterval = 30000; // 30 seconds
      const maxDuration = 45; // 45 minutes
  
      const monitorLoop = async (): Promise<void> => {
          try {
              monitorData.pollCount++;
              const elapsedMinutes = Math.floor((Date.now() - new Date(monitorData.startedAt).getTime()) / 60000);
  
              const result = await DXPRestClient.getDatabaseExportStatus(
                  projectConfig.projectId,
                  projectConfig.apiKey!,
                  projectConfig.apiSecret!,
                  environment,
                  monitorData.databaseName,
                  exportId
              );
  
              const parsedStatus = this.parseExportStatus(result);
              monitorData.lastStatus = parsedStatus.status;
  
              (emitter as any).emit('progress', {
                  status: parsedStatus.status,
                  pollCount: monitorData.pollCount,
                  elapsedMinutes
              });
  
              if (parsedStatus.status === 'Succeeded') {
                  (emitter as any).emit('complete', {
                      exportId,
                      downloadUrl: parsedStatus.downloadUrl,
                      environment,
                      databaseName
                  });
  
                  if (emitter.intervalId) {
                      clearInterval(emitter.intervalId);
                  }
                  this.backgroundMonitors.delete(exportId);
  
                  // If autoDownload was requested, trigger background download
                  // DXP-184 FIX: Use background download to avoid blocking background monitor thread
                  if (monitorData.autoDownload && parsedStatus.downloadUrl) {
                      this.startBackgroundDatabaseDownload(
                          parsedStatus.downloadUrl,
                          downloadPath,
                          projectConfig.name,
                          environment,
                          databaseName
                      ).then(downloadId => {
                          OutputLogger.success(`✅ Auto-download started (background). Download ID: ${downloadId}`);
                      }).catch(error => {
                          OutputLogger.error(`Auto-download failed: ${error.message}`);
                      });
                  }
              } else if (parsedStatus.status === 'Failed') {
                  (emitter as any).emit('failed', { exportId, error: 'Export failed' });
                  if (emitter.intervalId) {
                      clearInterval(emitter.intervalId);
                  }
                  this.backgroundMonitors.delete(exportId);
              } else if (elapsedMinutes >= maxDuration) {
                  (emitter as any).emit('timeout', { exportId, elapsedMinutes });
                  if (emitter.intervalId) {
                      clearInterval(emitter.intervalId);
                  }
                  this.backgroundMonitors.delete(exportId);
              }
          } catch (error: any) {
              (emitter as any).emit('error', { exportId, error: error.message });
          }
      };
  
      // Start polling
      emitter.intervalId = setInterval(monitorLoop, pollInterval);
      monitorLoop(); // Immediate first check
  
      OutputLogger.info(`Started background monitoring for export ${exportId}`);
  }

• lib/utils/tool-availability-matrix.ts:304-308 (registration)

  Tool listed in availability matrix as available for all hosting types in 'Monitoring' category.

  'list_monitors': {
      hostingTypes: ['dxp-paas', 'dxp-saas', 'self-hosted', 'unknown'],
      category: 'Monitoring',
      description: 'List active monitors'
  },