@172ai/containers-mcp-server 1.7.0 → 1.7.2

package/dist/services/buildService.js

@@ -4,6 +4,7 @@ exports.buildService = exports.BuildService = void 0;
 const auth_1 = require("../auth");
 const errorHandler_1 = require("../utils/errorHandler");
 const enhancedErrorHandler_1 = require("../utils/enhancedErrorHandler");
+const streamingService_1 = require("./streamingService");
 /**
  * Generate a unique request ID
  */
@@ -13,8 +14,9 @@ function generateRequestId() {
 class BuildService {
     constructor() {
         this.mcpServer = null;
-        // Phase 3: Multi-build stream management
-        this.activeMonitors = new Map();
+        // Real-time streaming management (replaces polling)
+        this.activeStreams = new Map();
+        this.progressUpdates = new Map();
         this.streamAnalytics = {
             totalBuilds: 0,
             activeBuilds: 0,
@@ -25,8 +27,6 @@ class BuildService {
             errorsEncountered: 0,
             lastActivity: new Date().toISOString()
         };
-        this.maxConcurrentBuilds = 10;
-        this.globalMonitoringTimeout = 900000; // 15 minutes
         this.httpClient = auth_1.authManager.getHttpClient();
     }
     /**
@@ -36,292 +36,79 @@ class BuildService {
         this.mcpServer = server;
     }
     /**
-     * Phase 3: Get stream analytics and monitoring information
+     * Get stream analytics and monitoring information
      */
     getStreamAnalytics() {
         return {
             ...this.streamAnalytics,
-            activeMonitors: Array.from(this.activeMonitors.values())
+            activeStreams: Array.from(this.activeStreams.values())
         };
     }
     /**
-     * Phase 3: Clean up completed or failed monitors
+     * Get progress update for a specific token
      */
-    cleanupInactiveMonitors() {
-        const now = Date.now();
-        for (const [token, monitor] of this.activeMonitors.entries()) {
-            if (monitor.status !== 'active' ||
-                (now - monitor.startTime) > this.globalMonitoringTimeout) {
-                if (monitor.timeoutHandle) {
-                    clearTimeout(monitor.timeoutHandle);
-                }
-                this.activeMonitors.delete(token);
-                this.streamAnalytics.activeBuilds = Math.max(0, this.streamAnalytics.activeBuilds - 1);
-            }
+    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;
     }
     /**
-     * Phase 3: Cancel a specific build monitor
+     * Get all progress updates for debugging
      */
-    async cancelBuildMonitoring(progressToken, reason = 'User requested cancellation') {
-        const monitor = this.activeMonitors.get(progressToken);
-        if (!monitor) {
-            return false;
-        }
-        monitor.status = 'cancelled';
-        await this.sendProgressNotification(progressToken, monitor.lastProgress, 100, `Build monitoring cancelled: ${reason}`);
-        if (monitor.timeoutHandle) {
-            clearTimeout(monitor.timeoutHandle);
+    getAllProgressUpdates() {
+        const updates = {};
+        for (const [token, data] of this.progressUpdates.entries()) {
+            updates[token] = data;
         }
-        this.activeMonitors.delete(progressToken);
-        this.streamAnalytics.activeBuilds = Math.max(0, this.streamAnalytics.activeBuilds - 1);
-        console.log(`[MCP] Cancelled monitoring for build ${monitor.buildId} with token ${progressToken}`);
-        return true;
+        return updates;
     }
     /**
-     * Send MCP progress notification with Phase 3 enhancements
+     * Cancel build monitoring for a specific token
      */
-    async sendProgressNotification(progressToken, progress, total = 100, message, metadata) {
-        if (!this.mcpServer || !progressToken) {
-            return;
+    async cancelBuildMonitoring(progressToken, reason = 'User requested cancellation') {
+        const stream = this.activeStreams.get(progressToken);
+        if (!stream) {
+            return false;
         }
+        console.log(`[Build] Cancelling monitoring for build ${stream.buildId} with token ${progressToken}`);
         try {
-            // Phase 3: Enhanced notification with metadata
-            const notificationParams = {
-                progressToken,
-                progress,
-                total,
-                message,
-                timestamp: new Date().toISOString(),
-                ...(metadata && { metadata })
-            };
-            await this.mcpServer.notification({
-                method: 'notifications/progress',
-                params: notificationParams
-            });
-            // Phase 3: Update analytics
-            this.streamAnalytics.notificationsSent++;
-            this.streamAnalytics.lastActivity = new Date().toISOString();
-            console.log(`[MCP] Progress notification sent: ${progress}/${total} - ${message}`);
+            // Update progress with cancellation notice
+            await this.storeProgressUpdate(progressToken, stream.lastProgress, 100, `Build monitoring cancelled: ${reason}`);
+            // Unsubscribe from stream
+            await streamingService_1.streamingService.unsubscribeFromStream(stream.streamId);
+            // Cleanup
+            this.completeStream(progressToken, 'cancelled');
+            return true;
         }
         catch (error) {
-            console.error(`[MCP] Failed to send progress notification:`, error);
-            this.streamAnalytics.errorsEncountered++;
-            // Phase 3: Enhanced error handling - attempt retry for critical notifications
-            if (progress === 100 || progress === 0) {
-                console.log(`[MCP] Retrying critical notification for ${progressToken}`);
-                setTimeout(() => {
-                    this.sendProgressNotification(progressToken, progress, total, `[RETRY] ${message}`, metadata);
-                }, 2000);
-            }
-        }
-    }
-    /**
-     * Phase 3: Enhanced build progress monitoring with multi-stream management
-     */
-    startBuildProgressMonitoring(containerId, buildId, progressToken) {
-        // Phase 3: Check for concurrent build limits
-        this.cleanupInactiveMonitors();
-        if (this.activeMonitors.size >= this.maxConcurrentBuilds) {
-            console.log(`[MCP] Maximum concurrent builds reached (${this.maxConcurrentBuilds}), queuing build ${buildId}`);
-            this.sendProgressNotification(progressToken, 5, 100, `Build queued - ${this.activeMonitors.size} builds in progress`);
-            // In a real implementation, you might want to queue this build
-            return;
-        }
-        // Phase 3: Create monitor entry
-        const monitor = {
-            containerId,
-            buildId,
-            progressToken,
-            startTime: Date.now(),
-            lastProgress: 10,
-            lastLogCount: 0,
-            status: 'active',
-            retryCount: 0
-        };
-        this.activeMonitors.set(progressToken, monitor);
-        this.streamAnalytics.totalBuilds++;
-        this.streamAnalytics.activeBuilds++;
-        // Run monitoring in background without blocking the main response
-        setImmediate(async () => {
-            console.log(`[MCP] Starting enhanced progress monitoring for build ${buildId} with token ${progressToken}`);
-            const enhancedMonitor = async () => {
-                const currentMonitor = this.activeMonitors.get(progressToken);
-                if (!currentMonitor || currentMonitor.status !== 'active') {
-                    return; // Monitor was cancelled or completed
-                }
-                try {
-                    // Phase 3: Enhanced timeout handling
-                    const elapsed = Date.now() - currentMonitor.startTime;
-                    if (elapsed > this.globalMonitoringTimeout) {
-                        console.log(`[MCP] Build monitoring timeout for ${buildId} after ${elapsed}ms`);
-                        currentMonitor.status = 'error';
-                        await this.sendProgressNotification(progressToken, 100, 100, 'Build monitoring timeout - check build status manually', {
-                            elapsedTime: elapsed,
-                            reason: 'timeout'
-                        });
-                        this.completeMonitoring(progressToken, 'timeout');
-                        return;
-                    }
-                    // Phase 3: Smart progress calculation with retry logic
-                    let buildStatus;
-                    try {
-                        buildStatus = await this.getBuildStatus({ containerId, buildId });
-                    }
-                    catch (statusError) {
-                        currentMonitor.retryCount++;
-                        if (currentMonitor.retryCount > 3) {
-                            currentMonitor.status = 'error';
-                            await this.sendProgressNotification(progressToken, currentMonitor.lastProgress, 100, `Build status check failed after ${currentMonitor.retryCount} retries`);
-                            this.completeMonitoring(progressToken, 'api_error');
-                            return;
-                        }
-                        console.log(`[MCP] Build status check failed (attempt ${currentMonitor.retryCount}), retrying...`);
-                        setTimeout(enhancedMonitor, 5000); // Exponential backoff would be better
-                        return;
-                    }
-                    // Reset retry count on successful API call
-                    currentMonitor.retryCount = 0;
-                    // Phase 3: Enhanced progress calculation
-                    const apiProgress = buildStatus.progress || 0;
-                    const timeBasedProgress = Math.min((elapsed / 300000) * 80, 80); // 80% progress over 5 minutes
-                    const combinedProgress = Math.max(apiProgress, timeBasedProgress, currentMonitor.lastProgress);
-                    // Send progress update if changed significantly
-                    if (combinedProgress > currentMonitor.lastProgress + 5 ||
-                        buildStatus.status !== currentMonitor.lastStatus) {
-                        const progressMetadata = {
-                            buildStatus: buildStatus.status,
-                            elapsedTime: elapsed,
-                            apiProgress,
-                            timeBasedProgress,
-                            buildId,
-                            containerId
-                        };
-                        await this.sendProgressNotification(progressToken, Math.min(combinedProgress, 99), // Cap at 99% until completion
-                        100, `Build ${buildStatus.status}: ${Math.round(combinedProgress)}% (${Math.round(elapsed / 1000)}s elapsed)`, progressMetadata);
-                        currentMonitor.lastProgress = combinedProgress;
-                        currentMonitor.lastStatus = buildStatus.status;
-                    }
-                    // Phase 3: Enhanced completion detection
-                    if (buildStatus.status === 'completed') {
-                        currentMonitor.status = 'completed';
-                        const completionTime = Date.now() - currentMonitor.startTime;
-                        await this.sendProgressNotification(progressToken, 100, 100, `Build completed successfully! (${Math.round(completionTime / 1000)}s total)`, {
-                            completionTime,
-                            buildId,
-                            finalStatus: 'completed'
-                        });
-                        this.completeMonitoring(progressToken, 'completed', completionTime);
-                        return;
-                    }
-                    if (buildStatus.status === 'failed') {
-                        currentMonitor.status = 'failed';
-                        await this.sendProgressNotification(progressToken, currentMonitor.lastProgress, 100, `Build failed: ${buildStatus.error || 'Unknown error'}`, {
-                            error: buildStatus.error,
-                            buildId,
-                            finalStatus: 'failed'
-                        });
-                        this.completeMonitoring(progressToken, 'failed');
-                        return;
-                    }
-                    if (buildStatus.status === 'cancelled') {
-                        currentMonitor.status = 'cancelled';
-                        await this.sendProgressNotification(progressToken, currentMonitor.lastProgress, 100, 'Build was cancelled', {
-                            buildId,
-                            finalStatus: 'cancelled'
-                        });
-                        this.completeMonitoring(progressToken, 'cancelled');
-                        return;
-                    }
-                    // Phase 3: Enhanced log-based progress estimation
-                    try {
-                        const logs = await this.getBuildLogs(containerId, buildId);
-                        if (logs.length > currentMonitor.lastLogCount) {
-                            const newLogCount = logs.length - currentMonitor.lastLogCount;
-                            currentMonitor.lastLogCount = logs.length;
-                            // More sophisticated progress estimation
-                            const logBasedProgress = Math.min(20 + (logs.length * 1.5), 90);
-                            if (logBasedProgress > currentMonitor.lastProgress) {
-                                await this.sendProgressNotification(progressToken, logBasedProgress, 100, `Build in progress - ${newLogCount} new log entries (${logs.length} total)`, { logCount: logs.length, newLogs: newLogCount });
-                                currentMonitor.lastProgress = logBasedProgress;
-                            }
-                        }
-                    }
-                    catch (logError) {
-                        // Log errors are not critical for progress monitoring
-                        console.log(`[MCP] Could not fetch logs for progress estimation: ${logError.message || 'Unknown error'}`);
-                    }
-                    // Continue monitoring if build is still running
-                    if (['pending', 'running', 'in_progress'].includes(buildStatus.status)) {
-                        // Phase 3: Adaptive polling interval based on build age and activity
-                        const adaptiveInterval = elapsed > 180000 ? 5000 : 3000; // Slower polling for older builds
-                        currentMonitor.timeoutHandle = setTimeout(enhancedMonitor, adaptiveInterval);
-                    }
-                }
-                catch (error) {
-                    console.error(`[MCP] Error in enhanced build progress monitoring:`, error);
-                    currentMonitor.retryCount++;
-                    this.streamAnalytics.errorsEncountered++;
-                    if (currentMonitor.retryCount <= 3) {
-                        await this.sendProgressNotification(progressToken, currentMonitor.lastProgress, 100, `Progress monitoring error (attempt ${currentMonitor.retryCount}) - retrying...`);
-                        setTimeout(enhancedMonitor, 10000); // Wait 10s before retry
-                    }
-                    else {
-                        currentMonitor.status = 'error';
-                        await this.sendProgressNotification(progressToken, currentMonitor.lastProgress, 100, 'Progress monitoring failed after multiple retries - build may still be running');
-                        this.completeMonitoring(progressToken, 'monitoring_error');
-                    }
-                }
-            };
-            // Start enhanced monitoring
-            await enhancedMonitor();
-        });
-    }
-    /**
-     * Phase 3: Complete monitoring and update analytics
-     */
-    completeMonitoring(progressToken, reason, completionTime) {
-        const monitor = this.activeMonitors.get(progressToken);
-        if (monitor) {
-            if (monitor.timeoutHandle) {
-                clearTimeout(monitor.timeoutHandle);
-            }
-            this.activeMonitors.delete(progressToken);
-            this.streamAnalytics.activeBuilds = Math.max(0, this.streamAnalytics.activeBuilds - 1);
-            // Update completion statistics
-            if (reason === 'completed') {
-                this.streamAnalytics.completedBuilds++;
-                if (completionTime) {
-                    const currentAvg = this.streamAnalytics.averageBuildTime;
-                    const totalCompleted = this.streamAnalytics.completedBuilds;
-                    this.streamAnalytics.averageBuildTime =
-                        ((currentAvg * (totalCompleted - 1)) + completionTime) / totalCompleted;
-                }
-            }
-            else if (reason === 'failed' || reason === 'monitoring_error' || reason === 'api_error') {
-                this.streamAnalytics.failedBuilds++;
-            }
-            console.log(`[MCP] Monitoring completed for ${monitor.buildId} (${reason})`);
+            console.error(`[Build] Error cancelling monitoring for token ${progressToken}:`, error);
+            return false;
         }
     }
     /**
-     * Start a container build with optional progress tracking
+     * Start a container build with real-time streaming progress
      */
     async buildContainer(params, progressToken) {
         try {
             if (!params.containerId) {
                 throw errorHandler_1.ErrorHandler.createValidationError('Container ID is required');
             }
-            // Phase 2: Initialize progress tracking with MCP notifications
+            // Initialize progress tracking with streaming notifications
             if (progressToken) {
-                console.log(`[MCP] Build started with progress token: ${progressToken} for container: ${params.containerId}`);
-                await this.sendProgressNotification(progressToken, 0, 100, 'Build initialization started');
+                console.log(`[Build] Starting build with streaming progress token: ${progressToken} for container: ${params.containerId}`);
+                await this.storeProgressUpdate(progressToken, 0, 100, 'Build initialization started');
             }
             const buildRequest = {
                 buildArgs: params.buildArgs || {},
                 target: params.target
             };
-            // Use the correct endpoint: POST /v1/containers/{id}/build (not builds)
+            // Start the build via API
             const response = await this.httpClient.post(`/v1/containers/${params.containerId}/build`, buildRequest);
             if (!response.data) {
                 throw errorHandler_1.ErrorHandler.createServerError('Invalid response from build start API');
@@ -338,11 +125,11 @@ class BuildService {
                 error: data.error,
                 logs: data.logs
             };
-            // Phase 2: Send progress notification for build started
+            // Set up real-time streaming for progress updates
             if (progressToken) {
-                await this.sendProgressNotification(progressToken, 10, 100, `Build started - ID: ${buildResult.id}`);
-                // Start monitoring build progress in background
-                this.startBuildProgressMonitoring(params.containerId, buildResult.id, progressToken);
+                await this.storeProgressUpdate(progressToken, 10, 100, `Build started - ID: ${buildResult.id}`);
+                // Create streaming subscription instead of polling
+                await this.setupStreamingMonitoring(params.containerId, buildResult.id, progressToken);
             }
             return buildResult;
         }
@@ -374,6 +161,195 @@ class BuildService {
             throw new errorHandler_1.ApiError(enhancedError.message, enhancedError.status, enhancedError.code, enhancedError, context.requestId, context.operation);
         }
     }
+    /**
+     * Set up real-time streaming monitoring for build progress
+     * Replaces the old polling-based monitoring system
+     */
+    async setupStreamingMonitoring(containerId, buildId, progressToken) {
+        try {
+            console.log(`[Build] Setting up real-time streaming for build ${buildId} with token ${progressToken}`);
+            // Create build stream
+            const streamSession = await streamingService_1.streamingService.createStream({
+                streamType: 'build',
+                resourceId: containerId,
+                eventFilters: [
+                    'build-started',
+                    'build-step-completed',
+                    'build-completed',
+                    'build-failed',
+                    'build-cancelled'
+                ],
+                ttlMinutes: 120, // 2 hours
+                metadata: {
+                    buildId,
+                    progressToken
+                }
+            });
+            // Track active stream
+            const activeStream = {
+                containerId,
+                buildId,
+                progressToken,
+                streamId: streamSession.streamId,
+                startTime: Date.now(),
+                lastProgress: 10,
+                status: 'active'
+            };
+            this.activeStreams.set(progressToken, activeStream);
+            this.streamAnalytics.totalBuilds++;
+            this.streamAnalytics.activeBuilds++;
+            // Subscribe to stream events
+            await streamingService_1.streamingService.subscribeToStream(streamSession.streamId, (event) => {
+                this.handleBuildStreamEvent(event, progressToken);
+            });
+            console.log(`[Build] Real-time streaming active for build ${buildId} (stream: ${streamSession.streamId})`);
+        }
+        catch (error) {
+            console.error(`[Build] Failed to setup streaming monitoring:`, error);
+            // Fallback to basic progress tracking if streaming fails
+            await this.storeProgressUpdate(progressToken, 10, 100, 'Build started - streaming unavailable, check build status manually');
+            // Don't throw - let build continue even if streaming fails
+        }
+    }
+    /**
+     * Handle real-time build stream events
+     */
+    async handleBuildStreamEvent(event, progressToken) {
+        try {
+            const stream = this.activeStreams.get(progressToken);
+            if (!stream) {
+                console.warn(`[Build] Received event for unknown progress token: ${progressToken}`);
+                return;
+            }
+            console.log(`[Build] Processing ${event.eventType} for build ${stream.buildId}: ${event.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 (['build-completed', 'build-failed', 'build-cancelled'].includes(event.eventType)) {
+                const completionTime = Date.now() - stream.startTime;
+                this.completeStream(progressToken, event.eventType.replace('build-', ''), completionTime);
+            }
+        }
+        catch (error) {
+            console.error(`[Build] 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,
+                buildId: stream.buildId,
+                containerId: stream.containerId,
+                streamId: stream.streamId,
+                ...event.data.details
+            }
+        };
+        switch (event.eventType) {
+            case 'build-started':
+                return {
+                    ...baseProgress,
+                    progress: 0,
+                    message: event.data.message || 'Build started'
+                };
+            case 'build-step-completed':
+                return {
+                    ...baseProgress,
+                    progress: event.data.progress || 0,
+                    message: event.data.message || `Step ${event.data.stepNumber}/${event.data.totalSteps} completed`
+                };
+            case 'build-completed':
+                return {
+                    ...baseProgress,
+                    progress: 100,
+                    message: event.data.message || 'Build completed successfully!'
+                };
+            case 'build-failed':
+                return {
+                    ...baseProgress,
+                    progress: Math.max(stream.lastProgress, 0),
+                    message: event.data.message || 'Build failed'
+                };
+            case 'build-cancelled':
+                return {
+                    ...baseProgress,
+                    progress: Math.max(stream.lastProgress, 0),
+                    message: event.data.message || 'Build cancelled'
+                };
+            default:
+                return {
+                    ...baseProgress,
+                    progress: Math.max(stream.lastProgress, 0),
+                    message: event.data.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(`[Build] Progress stored: ${progress}/${total} - ${message} (token: ${progressToken})`);
+        }
+        catch (error) {
+            console.error(`[Build] 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_1.streamingService.unsubscribeFromStream(stream.streamId).catch(error => {
+            console.error(`[Build] Error unsubscribing from stream ${stream.streamId}:`, error);
+        });
+        // Update analytics
+        this.streamAnalytics.activeBuilds = Math.max(0, this.streamAnalytics.activeBuilds - 1);
+        if (reason === 'completed') {
+            this.streamAnalytics.completedBuilds++;
+            if (completionTime) {
+                const currentAvg = this.streamAnalytics.averageBuildTime;
+                const totalCompleted = this.streamAnalytics.completedBuilds;
+                this.streamAnalytics.averageBuildTime =
+                    ((currentAvg * (totalCompleted - 1)) + completionTime) / totalCompleted;
+            }
+        }
+        else if (reason === 'failed') {
+            this.streamAnalytics.failedBuilds++;
+        }
+        // Clean up
+        this.activeStreams.delete(progressToken);
+        console.log(`[Build] Stream monitoring completed for ${stream.buildId} (${reason})`);
+    }
+    // Keep existing API methods unchanged for backward compatibility
     /**
      * Get build status
      */
@@ -382,14 +358,11 @@ class BuildService {
             if (!params.containerId) {
                 throw errorHandler_1.ErrorHandler.createValidationError('Container ID is required');
             }
-            // Use the build logs endpoint to get build status
-            // The server provides build logs at /v1/containers/{id}/builds/{buildId}
             let endpoint = `/v1/containers/${params.containerId}/builds`;
             if (params.buildId) {
                 endpoint += `/${params.buildId}`;
             }
             else {
-                // List all builds for the container and get the latest
                 const builds = await this.listBuilds({ containerId: params.containerId, limit: 1 });
                 if (builds.builds.length === 0) {
                     throw errorHandler_1.ErrorHandler.createNotFoundError(`No builds found for container ${params.containerId}`);
@@ -420,7 +393,6 @@ class BuildService {
     async listBuilds(params = {}) {
         try {
             if (!params.containerId) {
-                // No global builds endpoint available, return empty list
                 return {
                     builds: [],
                     total: 0,
@@ -436,14 +408,12 @@ class BuildService {
                 queryParams.append('limit', params.limit.toString());
             if (params.offset)
                 queryParams.append('offset', params.offset.toString());
-            // Use the container-specific builds endpoint (for build logs)
             const endpoint = `/v1/containers/${params.containerId}/builds`;
             const response = await this.httpClient.get(`${endpoint}?${queryParams.toString()}`);
             if (!response.data) {
                 throw errorHandler_1.ErrorHandler.createServerError('Invalid response format from builds list API');
             }
             const data = response.data;
-            // Handle case where response is an array directly (build logs)
             let builds = [];
             let total = 0;
             if (Array.isArray(data)) {
@@ -455,7 +425,6 @@ class BuildService {
                 total = data.total || data.builds.length;
             }
             else {
-                // No builds found
                 builds = [];
                 total = 0;
             }
@@ -469,7 +438,6 @@ class BuildService {
         }
         catch (error) {
             if (error instanceof errorHandler_1.ApiError && error.status === 404) {
-                // No builds found, return empty list
                 return {
                     builds: [],
                     total: 0,
@@ -489,19 +457,15 @@ class BuildService {
             if (!containerId) {
                 throw errorHandler_1.ErrorHandler.createValidationError('Container ID is required');
             }
-            // The logs are actually contained within the build details response
-            // Use the build details endpoint instead of a separate logs endpoint
             let endpoint = `/v1/containers/${containerId}/builds`;
             if (buildId) {
                 endpoint += `/${buildId}`;
             }
             else {
-                // Get the latest build first
                 const builds = await this.listBuilds({ containerId, limit: 1 });
                 if (builds.builds.length === 0) {
-                    return []; // No builds found
+                    return [];
                 }
-                // Use the latest build ID
                 buildId = builds.builds[0].id;
                 endpoint += `/${buildId}`;
             }
@@ -509,13 +473,11 @@ class BuildService {
             if (!response.data) {
                 return [];
             }
-            // Handle the API response format where logs are in the 'entries' field
             const buildData = response.data;
             const entries = buildData.entries || [];
             if (!Array.isArray(entries)) {
-                return []; // No logs available yet
+                return [];
             }
-            // Transform entries to BuildLogEntry format
             return entries.map((entry, index) => ({
                 id: entry.id || `${containerId}-${buildId}-${index}`,
                 containerId: containerId,
@@ -529,135 +491,11 @@ class BuildService {
         }
         catch (error) {
             if (error instanceof errorHandler_1.ApiError && error.status === 404) {
-                return []; // No logs available yet
+                return [];
             }
             throw errorHandler_1.ErrorHandler.processError(error, 'BuildService.getBuildLogs');
         }
     }
-    /**
-     * Cancel a running build
-     */
-    async cancelBuild(containerId, buildId) {
-        try {
-            if (!containerId) {
-                throw errorHandler_1.ErrorHandler.createValidationError('Container ID is required');
-            }
-            if (!buildId) {
-                throw errorHandler_1.ErrorHandler.createValidationError('Build ID is required');
-            }
-            await this.httpClient.post(`/v1/containers/${containerId}/builds/${buildId}/cancel`);
-            return {
-                success: true,
-                message: `Build ${buildId} cancelled successfully`
-            };
-        }
-        catch (error) {
-            if (error instanceof errorHandler_1.ApiError && error.status === 404) {
-                throw errorHandler_1.ErrorHandler.createNotFoundError(`Build ${buildId} not found`);
-            }
-            throw errorHandler_1.ErrorHandler.processError(error, 'BuildService.cancelBuild');
-        }
-    }
-    /**
-     * Retry a failed build
-     */
-    async retryBuild(containerId, buildId) {
-        try {
-            if (!containerId) {
-                throw errorHandler_1.ErrorHandler.createValidationError('Container ID is required');
-            }
-            if (!buildId) {
-                throw errorHandler_1.ErrorHandler.createValidationError('Build ID is required');
-            }
-            const response = await this.httpClient.post(`/v1/containers/${containerId}/builds/${buildId}/retry`);
-            if (!response.data) {
-                throw errorHandler_1.ErrorHandler.createServerError('Invalid response from build retry API');
-            }
-            return response.data;
-        }
-        catch (error) {
-            if (error instanceof errorHandler_1.ApiError && error.status === 404) {
-                throw errorHandler_1.ErrorHandler.createNotFoundError(`Build ${buildId} not found`);
-            }
-            throw errorHandler_1.ErrorHandler.processError(error, 'BuildService.retryBuild');
-        }
-    }
-    /**
-     * Get build statistics
-     */
-    async getBuildStats(containerId) {
-        try {
-            let endpoint = '/v1/builds/stats';
-            if (containerId) {
-                endpoint = `/v1/containers/${containerId}/builds/stats`;
-            }
-            const response = await this.httpClient.get(endpoint);
-            if (!response.data) {
-                return { total: 0, completed: 0, failed: 0, running: 0, pending: 0 };
-            }
-            return {
-                total: response.data.total || 0,
-                completed: response.data.completed || 0,
-                failed: response.data.failed || 0,
-                running: response.data.running || 0,
-                pending: response.data.pending || 0
-            };
-        }
-        catch (error) {
-            if (error instanceof errorHandler_1.ApiError && error.status === 404) {
-                return { total: 0, completed: 0, failed: 0, running: 0, pending: 0 };
-            }
-            throw errorHandler_1.ErrorHandler.processError(error, 'BuildService.getBuildStats');
-        }
-    }
-    /**
-     * Stream build logs (for real-time updates)
-     */
-    async streamBuildLogs(containerId, buildId, onLog, onError, onComplete) {
-        try {
-            if (!containerId) {
-                throw errorHandler_1.ErrorHandler.createValidationError('Container ID is required');
-            }
-            if (!buildId) {
-                throw errorHandler_1.ErrorHandler.createValidationError('Build ID is required');
-            }
-            // For now, implement polling-based streaming
-            // In a real implementation, this could use Server-Sent Events or WebSockets
-            let lastLogCount = 0;
-            const pollInterval = 2000; // 2 seconds
-            const poll = async () => {
-                try {
-                    const logs = await this.getBuildLogs(containerId, buildId);
-                    // Send only new logs
-                    if (logs.length > lastLogCount) {
-                        const newLogs = logs.slice(lastLogCount);
-                        newLogs.forEach(log => onLog(log));
-                        lastLogCount = logs.length;
-                    }
-                    // Check if build is complete
-                    const buildStatus = await this.getBuildStatus({ containerId, buildId });
-                    if (buildStatus.status === 'completed' || buildStatus.status === 'failed' || buildStatus.status === 'cancelled') {
-                        if (onComplete) {
-                            onComplete();
-                        }
-                        return;
-                    }
-                    // Continue polling
-                    setTimeout(poll, pollInterval);
-                }
-                catch (error) {
-                    if (onError) {
-                        onError(error);
-                    }
-                }
-            };
-            // Start polling
-            poll();
-        }
-        catch (error) {
-            throw errorHandler_1.ErrorHandler.processError(error, 'BuildService.streamBuildLogs');
-        }
-    }
 }
 exports.BuildService = BuildService;
 // Export singleton instance