@172ai/containers-mcp-server 1.12.2 → 1.12.4

package/dist/services/exportService.js

@@ -0,0 +1,659 @@
+import { authManager } from '../auth.js';
+import { ErrorHandler, ApiError } from '../utils/errorHandler.js';
+import { EnhancedMCPErrorHandler, MCP_ERROR_CODES, MCPError } from '../utils/enhancedErrorHandler.js';
+import { streamingService } from './streamingService.js';
+/**
+ * Generate a unique request ID
+ */
+function generateRequestId() {
+    return `mcp_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+}
+export class ExportService {
+    constructor() {
+        this.mcpServer = null;
+        // Real-time streaming management
+        this.activeStreams = new Map();
+        this.progressUpdates = new Map();
+        this.streamAnalytics = {
+            totalExports: 0,
+            activeExports: 0,
+            completedExports: 0,
+            failedExports: 0,
+            averageExportTime: 0,
+            notificationsSent: 0,
+            errorsEncountered: 0,
+            lastActivity: new Date().toISOString()
+        };
+        this.httpClient = authManager.getHttpClient();
+    }
+    /**
+     * Set MCP server reference for progress notifications
+     */
+    setMCPServer(server) {
+        this.mcpServer = server;
+    }
+    /**
+     * Get stream analytics and monitoring information
+     */
+    getStreamAnalytics() {
+        return {
+            ...this.streamAnalytics,
+            activeStreams: Array.from(this.activeStreams.values())
+        };
+    }
+    /**
+     * Get progress update for a specific token
+     */
+    getProgressUpdate(progressToken) {
+        const update = this.progressUpdates.get(progressToken);
+        if (!update)
+            return null;
+        // Check if expired (clean up stale data)
+        if (update.expiresAt && Date.now() > update.expiresAt) {
+            this.progressUpdates.delete(progressToken);
+            return null;
+        }
+        return update;
+    }
+    /**
+     * Cancel export monitoring for a specific token
+     */
+    async cancelExportMonitoring(progressToken, reason = 'User requested cancellation') {
+        const stream = this.activeStreams.get(progressToken);
+        if (!stream) {
+            return false;
+        }
+        console.log(`[Export] Cancelling monitoring for export job ${stream.jobId} with token ${progressToken}`);
+        try {
+            // Update progress with cancellation notice
+            await this.storeProgressUpdate(progressToken, stream.lastProgress, 100, `Export monitoring cancelled: ${reason}`);
+            // Unsubscribe from stream
+            await streamingService.unsubscribeFromStream(stream.streamId);
+            // Cleanup
+            this.completeStream(progressToken, 'cancelled');
+            return true;
+        }
+        catch (error) {
+            console.error(`[Export] Error cancelling monitoring for token ${progressToken}:`, error);
+            return false;
+        }
+    }
+    /**
+     * Start a container export with real-time streaming progress
+     */
+    async exportContainer(params, progressToken) {
+        try {
+            const { containerId, destinationType, destination, options } = params;
+            if (!containerId || !destinationType || !destination) {
+                throw ErrorHandler.createValidationError('Container ID, destination type, and destination are required');
+            }
+            // Initialize progress tracking with streaming notifications
+            if (progressToken) {
+                console.log(`[Export] Starting export with streaming progress token: ${progressToken}`);
+                await this.storeProgressUpdate(progressToken, 0, 100, 'Export initialization started');
+            }
+            const exportRequest = {
+                destinationType,
+                destination,
+                options: options || {}
+            };
+            // Start the export via API
+            const response = await this.httpClient.post(`/v1/containers/${containerId}/export`, exportRequest);
+            if (!response.data) {
+                throw ErrorHandler.createServerError('Invalid response from export API');
+            }
+            const data = response.data;
+            const exportResult = {
+                jobId: data.jobId,
+                containerId: data.containerId || containerId,
+                containerName: data.containerName || '',
+                destinationType: data.destinationType,
+                destination: data.destination || destination,
+                status: data.status || 'pending',
+                progress: data.progress || {
+                    stage: 'pending',
+                    stageNumber: 0,
+                    totalStages: 7,
+                    percent: 0,
+                    message: 'Export queued'
+                },
+                result: data.result,
+                errors: data.errors || [],
+                tokenCost: data.tokenCost || 0,
+                createdAt: data.createdAt || new Date().toISOString(),
+                updatedAt: data.updatedAt || new Date().toISOString(),
+                completedAt: data.completedAt,
+                estimatedDuration: data.estimatedDuration,
+                metadata: data.metadata
+            };
+            // Set up real-time streaming for progress updates
+            if (progressToken) {
+                await this.storeProgressUpdate(progressToken, 5, 100, `Export job created - ID: ${exportResult.jobId}`);
+                // Create streaming subscription
+                await this.setupStreamingMonitoring(exportResult.jobId, containerId, destinationType, exportResult.containerName, progressToken);
+            }
+            return exportResult;
+        }
+        catch (error) {
+            // Use enhanced error handling for export operations
+            const context = {
+                operation: 'export_container',
+                containerId: params.containerId,
+                destinationType: params.destinationType,
+                exportStage: 'initialization',
+                progressToken: progressToken,
+                requestId: generateRequestId()
+            };
+            if (error instanceof ApiError && error.status === 402) {
+                throw new MCPError(MCP_ERROR_CODES.API_QUOTA_EXCEEDED, error.message || 'Insufficient tokens for export', context);
+            }
+            if (error instanceof ApiError && error.status === 400) {
+                throw new MCPError(MCP_ERROR_CODES.CONTAINER_STATE_INVALID, error.message || 'Invalid export request', context);
+            }
+            const enhancedError = EnhancedMCPErrorHandler.processError(error, context);
+            throw new ApiError(enhancedError.message, enhancedError.status, enhancedError.code, enhancedError, context.requestId, context.operation);
+        }
+    }
+    /**
+     * Set up real-time streaming monitoring for export progress
+     */
+    async setupStreamingMonitoring(jobId, containerId, destinationType, containerName, progressToken) {
+        try {
+            console.log(`[Export] Setting up real-time streaming for export job ${jobId} with token ${progressToken}`);
+            // Create export stream
+            const streamSession = await streamingService.createStream({
+                streamType: 'user-notifications',
+                resourceId: jobId,
+                eventFilters: [
+                    'export-started',
+                    'export-validating',
+                    'export-building',
+                    'export-preparing',
+                    'export-authenticating',
+                    'export-uploading',
+                    'export-pushing',
+                    'export-verifying',
+                    'export-completed',
+                    'export-failed'
+                ],
+                ttlMinutes: 120, // 2 hours
+                metadata: {
+                    jobId,
+                    containerId,
+                    progressToken,
+                    destinationType,
+                    containerName
+                }
+            });
+            // Track active stream
+            const activeStream = {
+                jobId,
+                containerId,
+                containerName,
+                destinationType,
+                progressToken,
+                streamId: streamSession.streamId,
+                startTime: Date.now(),
+                lastProgress: 5,
+                status: 'active'
+            };
+            this.activeStreams.set(progressToken, activeStream);
+            this.streamAnalytics.totalExports++;
+            this.streamAnalytics.activeExports++;
+            // Subscribe to stream events
+            await streamingService.subscribeToStream(streamSession.streamId, (event) => {
+                this.handleExportStreamEvent(event, progressToken);
+            });
+            console.log(`[Export] Real-time streaming active for export job ${jobId} (stream: ${streamSession.streamId})`);
+        }
+        catch (error) {
+            console.error(`[Export] Failed to setup streaming monitoring for job ${jobId}:`, {
+                error: error?.message || error,
+                stack: error?.stack,
+                jobId,
+                progressToken
+            });
+            // Fallback to basic progress tracking if streaming fails
+            await this.storeProgressUpdate(progressToken, 5, 100, `Export started - streaming unavailable: ${error?.message || 'Unknown error'}`);
+            // Start fallback polling mechanism
+            await this.startFallbackProgressPolling(jobId, progressToken);
+        }
+    }
+    /**
+     * Start fallback polling mechanism when streaming fails
+     */
+    async startFallbackProgressPolling(jobId, progressToken) {
+        console.log(`[Export] Starting fallback polling for export job ${jobId} with token ${progressToken}`);
+        const stream = this.activeStreams.get(progressToken);
+        if (!stream) {
+            console.error(`[Export] No stream found for token ${progressToken}`);
+            return;
+        }
+        // Start polling every 10 seconds
+        const pollInterval = setInterval(async () => {
+            try {
+                const exportStatus = await this.getExportStatus(jobId);
+                if (!this.activeStreams.has(progressToken)) {
+                    clearInterval(pollInterval);
+                    return;
+                }
+                const currentStream = this.activeStreams.get(progressToken);
+                let progress = currentStream.lastProgress;
+                let message = `Export ${exportStatus.status}`;
+                // Map export status to progress
+                switch (exportStatus.status) {
+                    case 'pending':
+                        progress = 5;
+                        message = 'Export queued and waiting to start';
+                        break;
+                    case 'validating':
+                        progress = 10;
+                        message = exportStatus.progress?.message || 'Validating export configuration';
+                        break;
+                    case 'building':
+                        progress = 30;
+                        message = exportStatus.progress?.message || 'Building container image';
+                        break;
+                    case 'preparing':
+                        progress = 40;
+                        message = exportStatus.progress?.message || 'Preparing export';
+                        break;
+                    case 'authenticating':
+                        progress = 50;
+                        message = exportStatus.progress?.message || 'Authenticating with destination';
+                        break;
+                    case 'uploading':
+                        progress = 70;
+                        message = exportStatus.progress?.message || 'Uploading files';
+                        break;
+                    case 'pushing':
+                        progress = 80;
+                        message = exportStatus.progress?.message || 'Pushing to destination';
+                        break;
+                    case 'verifying':
+                        progress = 95;
+                        message = exportStatus.progress?.message || 'Verifying export';
+                        break;
+                    case 'completed':
+                        progress = 100;
+                        message = this.getCompletionMessage(exportStatus);
+                        break;
+                    case 'failed':
+                        message = `Export failed: ${exportStatus.errors?.[0] || 'Unknown error'}`;
+                        break;
+                }
+                // Update progress
+                currentStream.lastProgress = progress;
+                await this.storeProgressUpdate(progressToken, progress, 100, message, {
+                    jobId,
+                    status: exportStatus.status,
+                    fallbackMode: true
+                });
+                // Complete if finished
+                if (['completed', 'failed', 'cancelled'].includes(exportStatus.status)) {
+                    const completionTime = Date.now() - currentStream.startTime;
+                    this.completeStream(progressToken, exportStatus.status === 'completed' ? 'completed' : 'failed', completionTime);
+                    clearInterval(pollInterval);
+                }
+            }
+            catch (error) {
+                console.error(`[Export] Error in fallback polling for ${jobId}:`, error);
+            }
+        }, 10000); // Poll every 10 seconds
+        // Auto-cleanup after 30 minutes
+        setTimeout(() => {
+            if (this.activeStreams.has(progressToken)) {
+                console.log(`[Export] Auto-cleaning up fallback polling for ${jobId} after 30 minutes`);
+                clearInterval(pollInterval);
+                this.completeStream(progressToken, 'timeout');
+            }
+        }, 30 * 60 * 1000);
+    }
+    /**
+     * Get completion message based on export result
+     */
+    getCompletionMessage(exportStatus) {
+        if (exportStatus.result?.imageUrl) {
+            return `Export completed! Image pushed to ${exportStatus.result.imageUrl}`;
+        }
+        if (exportStatus.result?.repositoryUrl) {
+            return `Export completed! Repository: ${exportStatus.result.repositoryUrl}`;
+        }
+        if (exportStatus.result?.downloadUrl) {
+            return `Export completed! Download ready (expires ${exportStatus.result.expiresAt})`;
+        }
+        return 'Export completed successfully!';
+    }
+    /**
+     * Handle real-time export stream events
+     */
+    async handleExportStreamEvent(event, progressToken) {
+        try {
+            const stream = this.activeStreams.get(progressToken);
+            if (!stream) {
+                console.warn(`[Export] Received event for unknown progress token: ${progressToken}`);
+                return;
+            }
+            console.log(`[Export] Processing ${event.eventType} for export job ${stream.jobId}: ${event.data.message || event.data.data?.message || ''}`);
+            // Convert stream event to progress update
+            const progressUpdate = this.convertStreamEventToProgress(event, progressToken, stream);
+            // Store progress update
+            await this.storeProgressUpdate(progressToken, progressUpdate.progress, progressUpdate.total, progressUpdate.message, progressUpdate.metadata);
+            // Update stream tracking
+            stream.lastProgress = progressUpdate.progress;
+            // Handle completion events
+            if (['export-completed', 'export-failed'].includes(event.eventType)) {
+                const completionTime = Date.now() - stream.startTime;
+                this.completeStream(progressToken, event.eventType.replace('export-', ''), completionTime);
+            }
+        }
+        catch (error) {
+            console.error(`[Export] Error handling stream event:`, error);
+            this.streamAnalytics.errorsEncountered++;
+        }
+    }
+    /**
+     * Convert stream event to progress update format
+     */
+    convertStreamEventToProgress(event, progressToken, stream) {
+        const baseProgress = {
+            progressToken,
+            total: 100,
+            timestamp: event.timestamp,
+            metadata: {
+                eventType: event.eventType,
+                jobId: stream.jobId,
+                containerId: stream.containerId,
+                destinationType: stream.destinationType,
+                streamId: stream.streamId,
+                ...event.data.data
+            }
+        };
+        const eventData = event.data.data || event.data;
+        switch (event.eventType) {
+            case 'export-started':
+                return {
+                    ...baseProgress,
+                    progress: 5,
+                    message: eventData.message || 'Export started'
+                };
+            case 'export-validating':
+                return {
+                    ...baseProgress,
+                    progress: 10,
+                    message: eventData.message || 'Validating export configuration'
+                };
+            case 'export-building':
+                return {
+                    ...baseProgress,
+                    progress: 30,
+                    message: eventData.message || 'Building container image'
+                };
+            case 'export-preparing':
+                return {
+                    ...baseProgress,
+                    progress: 40,
+                    message: eventData.message || 'Preparing export files'
+                };
+            case 'export-authenticating':
+                return {
+                    ...baseProgress,
+                    progress: 50,
+                    message: eventData.message || 'Authenticating with destination'
+                };
+            case 'export-uploading':
+                return {
+                    ...baseProgress,
+                    progress: 70,
+                    message: eventData.message || 'Uploading files to destination'
+                };
+            case 'export-pushing':
+                return {
+                    ...baseProgress,
+                    progress: 80,
+                    message: eventData.message || 'Pushing to registry/repository'
+                };
+            case 'export-verifying':
+                return {
+                    ...baseProgress,
+                    progress: 95,
+                    message: eventData.message || 'Verifying export completion'
+                };
+            case 'export-completed':
+                return {
+                    ...baseProgress,
+                    progress: 100,
+                    message: eventData.message || `Export completed successfully!`
+                };
+            case 'export-failed':
+                return {
+                    ...baseProgress,
+                    progress: Math.max(stream.lastProgress, 0),
+                    message: eventData.message || eventData.error || 'Export failed'
+                };
+            default:
+                return {
+                    ...baseProgress,
+                    progress: Math.max(stream.lastProgress, 0),
+                    message: eventData.message || `Unknown event: ${event.eventType}`
+                };
+        }
+    }
+    /**
+     * Store progress update with expiration
+     */
+    async storeProgressUpdate(progressToken, progress, total = 100, message, metadata) {
+        if (!progressToken)
+            return;
+        try {
+            const notificationData = {
+                progressToken,
+                progress,
+                total,
+                message,
+                timestamp: new Date().toISOString(),
+                expiresAt: Date.now() + (30 * 60 * 1000), // 30-minute expiration
+                ...(metadata && { metadata })
+            };
+            this.progressUpdates.set(progressToken, notificationData);
+            this.streamAnalytics.notificationsSent++;
+            this.streamAnalytics.lastActivity = new Date().toISOString();
+            console.log(`[Export] Progress stored: ${progress}/${total} - ${message} (token: ${progressToken})`);
+        }
+        catch (error) {
+            console.error(`[Export] Failed to store progress update:`, error);
+            this.streamAnalytics.errorsEncountered++;
+        }
+    }
+    /**
+     * Complete stream monitoring and update analytics
+     */
+    completeStream(progressToken, reason, completionTime) {
+        const stream = this.activeStreams.get(progressToken);
+        if (!stream)
+            return;
+        // Unsubscribe from stream
+        streamingService.unsubscribeFromStream(stream.streamId).catch(error => {
+            console.error(`[Export] Error unsubscribing from stream ${stream.streamId}:`, error);
+        });
+        // Update analytics
+        this.streamAnalytics.activeExports = Math.max(0, this.streamAnalytics.activeExports - 1);
+        if (reason === 'completed') {
+            this.streamAnalytics.completedExports++;
+            if (completionTime) {
+                const currentAvg = this.streamAnalytics.averageExportTime;
+                const totalCompleted = this.streamAnalytics.completedExports;
+                this.streamAnalytics.averageExportTime =
+                    ((currentAvg * (totalCompleted - 1)) + completionTime) / totalCompleted;
+            }
+        }
+        else if (reason === 'failed') {
+            this.streamAnalytics.failedExports++;
+        }
+        // Clean up
+        this.activeStreams.delete(progressToken);
+        console.log(`[Export] Stream monitoring completed for ${stream.jobId} (${reason})`);
+    }
+    /**
+     * Get export job status
+     */
+    async getExportStatus(jobId) {
+        try {
+            if (!jobId) {
+                throw ErrorHandler.createValidationError('Job ID is required');
+            }
+            const response = await this.httpClient.get(`/v1/containers/exports/${jobId}`);
+            if (!response.data || !response.data.export) {
+                throw ErrorHandler.createNotFoundError(`Export job ${jobId} not found`);
+            }
+            const job = response.data.export;
+            return {
+                jobId: job.jobId,
+                containerId: job.containerId,
+                containerName: job.containerName,
+                destinationType: job.destinationType,
+                destination: job.destination,
+                status: job.status,
+                progress: job.progress,
+                result: job.result,
+                errors: job.errors || [],
+                tokenCost: job.tokenCost,
+                createdAt: job.createdAt,
+                updatedAt: job.updatedAt,
+                completedAt: job.completedAt,
+                estimatedDuration: job.estimatedDuration,
+                metadata: job.metadata
+            };
+        }
+        catch (error) {
+            if (error instanceof ApiError && error.status === 404) {
+                throw ErrorHandler.createNotFoundError(`Export job ${jobId} not found`);
+            }
+            throw ErrorHandler.processError(error, 'ExportService.getExportStatus');
+        }
+    }
+    /**
+     * List export jobs
+     */
+    async listExportJobs(params = {}) {
+        try {
+            const queryParams = new URLSearchParams();
+            if (params.containerId)
+                queryParams.append('containerId', params.containerId);
+            if (params.status)
+                queryParams.append('status', params.status);
+            if (params.limit)
+                queryParams.append('limit', params.limit.toString());
+            if (params.offset)
+                queryParams.append('offset', params.offset.toString());
+            let endpoint = '/v1/users/me/exports';
+            if (params.containerId) {
+                endpoint = `/v1/containers/${params.containerId}/exports`;
+            }
+            const response = await this.httpClient.get(`${endpoint}?${queryParams.toString()}`);
+            if (!response.data) {
+                throw ErrorHandler.createServerError('Invalid response format from exports list API');
+            }
+            const data = response.data;
+            return {
+                exports: (data.exports || []).map((job) => ({
+                    jobId: job.jobId,
+                    containerId: job.containerId,
+                    containerName: job.containerName,
+                    destinationType: job.destinationType,
+                    destination: job.destination,
+                    status: job.status,
+                    progress: job.progress,
+                    result: job.result,
+                    errors: job.errors || [],
+                    tokenCost: job.tokenCost,
+                    createdAt: job.createdAt,
+                    updatedAt: job.updatedAt,
+                    completedAt: job.completedAt,
+                    estimatedDuration: job.estimatedDuration,
+                    metadata: job.metadata
+                })),
+                pagination: data.pagination || {
+                    limit: params.limit || 50,
+                    offset: params.offset || 0,
+                    total: data.exports?.length || 0,
+                    hasMore: false
+                }
+            };
+        }
+        catch (error) {
+            throw ErrorHandler.processError(error, 'ExportService.listExportJobs');
+        }
+    }
+    /**
+     * Get download URL for archive exports
+     */
+    async getExportDownloadUrl(jobId) {
+        try {
+            if (!jobId) {
+                throw ErrorHandler.createValidationError('Job ID is required');
+            }
+            const response = await this.httpClient.get(`/v1/containers/exports/${jobId}/download`);
+            if (!response.data) {
+                throw ErrorHandler.createServerError('Invalid response from download URL API');
+            }
+            return {
+                downloadUrl: response.data.downloadUrl,
+                expiresAt: response.data.expiresAt,
+                format: response.data.format,
+                size: response.data.size
+            };
+        }
+        catch (error) {
+            if (error instanceof ApiError && error.status === 404) {
+                throw ErrorHandler.createNotFoundError(`Export job ${jobId} not found or download not available`);
+            }
+            if (error instanceof ApiError && error.status === 410) {
+                throw ErrorHandler.createServerError('Download URL has expired');
+            }
+            throw ErrorHandler.processError(error, 'ExportService.getExportDownloadUrl');
+        }
+    }
+    /**
+     * Cancel an export job
+     */
+    async cancelExportJob(jobId) {
+        try {
+            if (!jobId) {
+                throw ErrorHandler.createValidationError('Job ID is required');
+            }
+            const response = await this.httpClient.delete(`/v1/containers/exports/${jobId}`);
+            if (!response.data || !response.data.export) {
+                throw ErrorHandler.createServerError('Invalid response from cancel export API');
+            }
+            const job = response.data.export;
+            return {
+                jobId: job.jobId,
+                containerId: job.containerId,
+                containerName: job.containerName,
+                destinationType: job.destinationType,
+                destination: job.destination,
+                status: job.status,
+                progress: job.progress,
+                result: job.result,
+                errors: job.errors || [],
+                tokenCost: job.tokenCost,
+                createdAt: job.createdAt,
+                updatedAt: job.updatedAt,
+                completedAt: job.completedAt
+            };
+        }
+        catch (error) {
+            if (error instanceof ApiError && error.status === 404) {
+                throw ErrorHandler.createNotFoundError(`Export job ${jobId} not found`);
+            }
+            if (error instanceof ApiError && error.status === 400) {
+                throw ErrorHandler.createValidationError('Cannot cancel export in current state');
+            }
+            throw ErrorHandler.processError(error, 'ExportService.cancelExportJob');
+        }
+    }
+}
+// Export singleton instance
+export const exportService = new ExportService();
+//# sourceMappingURL=exportService.js.map