@172ai/containers-mcp-server 1.12.5 → 1.12.7

package/dist/server.js

@@ -7,6 +7,7 @@ import { config } from './config.js';
 import { authManager } from './auth.js';
 import { containerService } from './services/containerService.js';
 import { buildService } from './services/buildService.js';
+import { fixService } from './services/fixService.js';
 import { fileService } from './services/fileService.js';
 import { capabilityService } from './services/capabilityService.js';
 import { executionService } from './services/executionService.js';
@@ -15,6 +16,7 @@ import { exportService } from './services/exportService.js';
 import { streamingService } from './services/streamingService.js';
 import { userNotificationManager } from './services/userNotificationManager.js';
 import { userService } from './services/userService.js';
+import { modificationService } from './services/modificationService.js';
 import { ErrorHandler } from './utils/errorHandler.js';
 /**
  * 172.ai Container Management MCP Server
@@ -30,9 +32,11 @@ class ContainerMCPServer {
         });
         // Initialize MCP server reference for progress notifications
         buildService.setMCPServer(this.server);
+        fixService.setMCPServer(this.server);
         executionService.setMCPServer(this.server);
         importService.setMCPServer(this.server);
         exportService.setMCPServer(this.server);
+        modificationService.setMCPServer(this.server);
         this.setupTools();
         this.setupErrorHandlers();
         this.initializeStreaming();
@@ -83,6 +87,8 @@ class ContainerMCPServer {
         this.setupContainerTools();
         // Build Management Tools
         this.setupBuildTools();
+        // Fix Management Tools
+        this.setupFixTools();
         // File Management Tools
         this.setupFileTools();
         // Capability Management Tools
@@ -90,6 +96,13 @@ class ContainerMCPServer {
         // Execution Management Tools
         this.setupExecutionTools();
     }
+    /**
+     * Set up container fix management tools
+     */
+    setupFixTools() {
+        // Fix tools are registered via CallToolRequestSchema handler
+        // No separate setup needed - they share the same request handler
+    }
     /**
      * Set up container management tools
      */
@@ -158,6 +171,16 @@ class ContainerMCPServer {
                         return await this.handleCancelBuildMonitoring(args);
                     case 'get_stream_analytics':
                         return await this.handleGetStreamAnalytics(args);
+                    case 'fix_container':
+                        return await this.handleFixContainer(args);
+                    case 'analyze_container_failure':
+                        return await this.handleAnalyzeContainerFailure(args);
+                    case 'approve_and_apply_fix':
+                        return await this.handleApproveAndApplyFix(args);
+                    case 'get_fix_history':
+                        return await this.handleGetFixHistory(args);
+                    case 'get_fix_status':
+                        return await this.handleGetFixStatus(args);
                     case 'import_container':
                         return await this.handleImportContainer(args);
                     case 'get_import_status':
@@ -236,6 +259,16 @@ class ContainerMCPServer {
                         return await this.handleGetExecutionProgressUpdate(args);
                     case 'get_all_progress_updates':
                         return await this.handleGetAllProgressUpdates(args);
+                    case 'list_modifications':
+                        return await this.handleListModifications(args);
+                    case 'suggest_container_modifications':
+                        return await this.handleSuggestContainerModifications(args);
+                    case 'apply_container_modification':
+                        return await this.handleApplyContainerModification(args);
+                    case 'get_modification_status':
+                        return await this.handleGetModificationStatus(args);
+                    case 'list_applied_modifications':
+                        return await this.handleListAppliedModifications(args);
                     default:
                         throw ErrorHandler.createValidationError(`Unknown tool: ${name}`);
                 }
@@ -765,6 +798,109 @@ Follow same metadata requirements as create_container.`,
                     }
                 }
             },
+            // Fix Management Tools
+            {
+                name: 'fix_container',
+                description: 'Analyze container build failure, apply AI-generated fix, and rebuild automatically. This is the primary fix workflow that combines analysis, application, and rebuild into one operation.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        containerId: {
+                            type: 'string',
+                            description: 'ID of the container to fix'
+                        },
+                        autoApply: {
+                            type: 'boolean',
+                            description: 'Whether to automatically apply the fix after analysis (default: true). Set to false for analyze-only mode.',
+                            default: true
+                        },
+                        progressToken: {
+                            type: 'string',
+                            description: 'Optional token for receiving real-time progress notifications during fix operation'
+                        }
+                    },
+                    required: ['containerId']
+                }
+            },
+            {
+                name: 'analyze_container_failure',
+                description: 'Analyze container build/execution failure and generate fix suggestions WITHOUT automatically applying them. Returns fixAttemptId for later approval.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        containerId: {
+                            type: 'string',
+                            description: 'ID of the container to analyze'
+                        },
+                        progressToken: {
+                            type: 'string',
+                            description: 'Optional token for receiving real-time progress notifications'
+                        }
+                    },
+                    required: ['containerId']
+                }
+            },
+            {
+                name: 'approve_and_apply_fix',
+                description: 'Apply a specific fix attempt and trigger automatic rebuild. Use this after reviewing analysis results from analyze_container_failure.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        containerId: {
+                            type: 'string',
+                            description: 'ID of the container'
+                        },
+                        fixAttemptId: {
+                            type: 'string',
+                            description: 'ID of the fix attempt to apply (from analyze_container_failure result)'
+                        },
+                        progressToken: {
+                            type: 'string',
+                            description: 'Optional token for receiving real-time progress notifications'
+                        }
+                    },
+                    required: ['containerId', 'fixAttemptId']
+                }
+            },
+            {
+                name: 'get_fix_history',
+                description: 'Get the history of fix attempts for a container, showing all previous fixes and their outcomes',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        containerId: {
+                            type: 'string',
+                            description: 'ID of the container'
+                        },
+                        limit: {
+                            type: 'number',
+                            minimum: 1,
+                            maximum: 100,
+                            description: 'Maximum number of fix attempts to return (default: 10)',
+                            default: 10
+                        }
+                    },
+                    required: ['containerId']
+                }
+            },
+            {
+                name: 'get_fix_status',
+                description: 'Get detailed status and information about a specific fix attempt',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        containerId: {
+                            type: 'string',
+                            description: 'ID of the container'
+                        },
+                        fixAttemptId: {
+                            type: 'string',
+                            description: 'ID of the fix attempt to retrieve'
+                        }
+                    },
+                    required: ['containerId', 'fixAttemptId']
+                }
+            },
             // Import Management Tools
             {
                 name: 'import_container',
@@ -1616,6 +1752,130 @@ Follow same metadata requirements as create_container.`,
                     type: 'object',
                     properties: {}
                 }
+            },
+            // Modification Management Tools
+            {
+                name: 'list_modifications',
+                description: 'List all available modifications in the catalog',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        category: {
+                            type: 'string',
+                            description: 'Filter by category (optional)'
+                        },
+                        tags: {
+                            type: 'string',
+                            description: 'Filter by tags (comma-separated, optional)'
+                        },
+                        active: {
+                            type: 'boolean',
+                            default: true,
+                            description: 'Filter by active status (default: true)'
+                        }
+                    }
+                }
+            },
+            {
+                name: 'suggest_container_modifications',
+                description: 'Get AI-powered modification suggestions for a container',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        containerId: {
+                            type: 'string',
+                            description: 'ID of the container to analyze'
+                        },
+                        categories: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'Filter suggestions by categories (optional)'
+                        },
+                        includeRisks: {
+                            type: 'boolean',
+                            default: true,
+                            description: 'Include risk assessment (default: true)'
+                        }
+                    },
+                    required: ['containerId']
+                }
+            },
+            {
+                name: 'apply_container_modification',
+                description: 'Apply a modification to a container',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        containerId: {
+                            type: 'string',
+                            description: 'ID of the container'
+                        },
+                        modificationId: {
+                            type: 'string',
+                            description: 'ID of the modification to apply'
+                        },
+                        autoBuild: {
+                            type: 'boolean',
+                            default: true,
+                            description: 'Automatically build after applying (default: true)'
+                        },
+                        notes: {
+                            type: 'string',
+                            description: 'Optional notes about this application'
+                        }
+                    },
+                    required: ['containerId', 'modificationId']
+                }
+            },
+            {
+                name: 'get_modification_status',
+                description: 'Get detailed information about a specific modification application',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        containerId: {
+                            type: 'string',
+                            description: 'ID of the container'
+                        },
+                        modificationApplicationId: {
+                            type: 'string',
+                            description: 'ID of the modification application'
+                        }
+                    },
+                    required: ['containerId', 'modificationApplicationId']
+                }
+            },
+            {
+                name: 'list_applied_modifications',
+                description: 'List modifications applied to a specific container',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        containerId: {
+                            type: 'string',
+                            description: 'ID of the container'
+                        },
+                        status: {
+                            type: 'string',
+                            enum: ['in_progress', 'completed', 'failed'],
+                            description: 'Filter by status (optional)'
+                        },
+                        limit: {
+                            type: 'number',
+                            minimum: 1,
+                            maximum: 100,
+                            default: 50,
+                            description: 'Maximum number of results (default: 50)'
+                        },
+                        offset: {
+                            type: 'number',
+                            minimum: 0,
+                            default: 0,
+                            description: 'Number of results to skip (default: 0)'
+                        }
+                    },
+                    required: ['containerId']
+                }
             }
         ];
     }
@@ -1939,6 +2199,151 @@ Follow same metadata requirements as create_container.`,
             ],
         };
     }
+    // Fix handler methods
+    async handleFixContainer(args) {
+        const { progressToken, autoApply = true, ...fixParams } = args;
+        const result = await fixService.fixContainer({
+            containerId: args.containerId,
+            autoApply,
+            progressToken
+        });
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `🔧 Fix operation ${autoApply ? 'started' : 'analyzed'} for container ${args.containerId}!\n\n` +
+                        `Fix Attempt ID: ${result.fixAttemptId}\n` +
+                        `Status: ${autoApply ? 'Applying fix and rebuilding' : 'Analysis complete - awaiting approval'}\n` +
+                        `Message: ${result.message}\n` +
+                        `${result.analysis ? `\nDiagnostic: ${result.analysis.diagnosticSummary}\nRoot Cause: ${result.analysis.rootCause}\n` : ''}` +
+                        `${result.buildStatus ? `Build Status: ${result.buildStatus}\n` : ''}` +
+                        `${progressToken ? `\n🔄 Progress updates will be sent via notifications using token: ${progressToken}` : ''}`,
+                },
+            ],
+        };
+    }
+    async handleAnalyzeContainerFailure(args) {
+        const { progressToken } = args;
+        const result = await fixService.analyzeFailure({
+            containerId: args.containerId,
+            progressToken
+        });
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `**Container Failure Analysis**\n\n` +
+                        `Fix Attempt ID: ${result.fixAttemptId}\n` +
+                        `Attempt: ${result.attemptNumber} of ${result.maxAttempts}\n` +
+                        `Previous Attempts: ${result.previousAttempts}\n\n` +
+                        `**Diagnostic Summary**\n${result.diagnosticSummary}\n\n` +
+                        `**Root Cause**\n${result.rootCause}\n\n` +
+                        `**Proposed Fix**\n${result.fixApproach}\n\n` +
+                        `**Severity**: ${result.severity}\n` +
+                        `**Fix Confidence**: ${result.fixConfidence}\n` +
+                        `**Affected Files**: ${result.affectedFiles.join(', ')}\n\n` +
+                        `💡 Use approve_and_apply_fix with fixAttemptId: ${result.fixAttemptId} to apply this fix`,
+                },
+            ],
+        };
+    }
+    async handleApproveAndApplyFix(args) {
+        const { progressToken } = args;
+        const result = await fixService.applyFix({
+            containerId: args.containerId,
+            fixAttemptId: args.fixAttemptId,
+            progressToken
+        });
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `✅ Fix approved and applied!\n\n` +
+                        `Fix Attempt ID: ${result.fixAttemptId}\n` +
+                        `Container ID: ${result.containerId}\n` +
+                        `Message: ${result.message}\n` +
+                        `Build Status: ${result.buildStatus}\n` +
+                        `${progressToken ? `\n🔄 Progress updates will be sent via notifications using token: ${progressToken}` : ''}`,
+                },
+            ],
+        };
+    }
+    async handleGetFixHistory(args) {
+        const result = await fixService.getFixHistory({
+            containerId: args.containerId,
+            limit: args.limit || 10
+        });
+        if (result.fixes.length === 0) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `No fix attempts found for container ${args.containerId}`,
+                    },
+                ],
+            };
+        }
+        let historyText = `**Fix History for Container ${args.containerId}**\n\n` +
+            `Found ${result.totalCount} fix attempt(s):\n\n`;
+        result.fixes.forEach((fix, index) => {
+            historyText += `${index + 1}. **Fix ${fix.id}**\n` +
+                `   • Attempt Number: ${fix.attemptNumber}\n` +
+                `   • Status: ${fix.status}\n` +
+                `   • Severity: ${fix.severity}\n` +
+                `   • Confidence: ${fix.fixConfidence}\n` +
+                `   • Created: ${fix.createdAt}\n` +
+                `   ${fix.appliedAt ? `• Applied: ${fix.appliedAt}\n` : ''}` +
+                `   ${fix.completedAt ? `• Completed: ${fix.completedAt}\n` : ''}` +
+                `   ${fix.errorMessage ? `• Error: ${fix.errorMessage}\n` : ''}\n`;
+        });
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: historyText,
+                },
+            ],
+        };
+    }
+    async handleGetFixStatus(args) {
+        const result = await fixService.getFixStatus({
+            containerId: args.containerId,
+            fixAttemptId: args.fixAttemptId
+        });
+        let statusText = `**Fix Attempt Status**\n\n` +
+            `Fix ID: ${result.id}\n` +
+            `Container ID: ${result.containerId}\n` +
+            `Attempt Number: ${result.attemptNumber}\n` +
+            `Status: ${result.status}\n` +
+            `Severity: ${result.severity}\n` +
+            `Fix Confidence: ${result.fixConfidence}\n\n` +
+            `**Diagnostic Summary**\n${result.diagnosticSummary}\n\n` +
+            `**Root Cause**\n${result.rootCause}\n\n` +
+            `**Fix Approach**\n${result.fixApproach}\n\n` +
+            `**Timeline**\n` +
+            `• Created: ${result.createdAt}\n` +
+            `${result.updatedAt ? `• Updated: ${result.updatedAt}\n` : ''}` +
+            `${result.appliedAt ? `• Applied: ${result.appliedAt}\n` : ''}` +
+            `${result.completedAt ? `• Completed: ${result.completedAt}\n` : ''}`;
+        if (result.fileChanges && result.fileChanges.length > 0) {
+            statusText += `\n**File Changes (${result.fileChanges.length})**\n`;
+            result.fileChanges.forEach((change, index) => {
+                statusText += `${index + 1}. ${change.filePath} (${change.changeType})\n` +
+                    `   Reason: ${change.changeReason}\n`;
+            });
+        }
+        if (result.errorMessage) {
+            statusText += `\n❌ **Error**: ${result.errorMessage}\n`;
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: statusText,
+                },
+            ],
+        };
+    }
     // Import handler methods
     async handleImportContainer(args) {
         const { progressToken, ...importParams } = args;
@@ -2856,6 +3261,148 @@ Follow same metadata requirements as create_container.`,
             ],
         };
     }
+    /**
+     * Handle list modifications
+     */
+    async handleListModifications(args) {
+        const { category, tags, active = true } = args;
+        const result = await modificationService.listModifications(category, tags, active);
+        let responseText = `**Available Modifications**\n\n`;
+        responseText += `Found ${result.count} modification(s)\n\n`;
+        result.modifications.forEach((mod, index) => {
+            responseText += `${index + 1}. **${mod.name}** (${mod.modificationId})\n`;
+            responseText += `   Category: ${mod.category}\n`;
+            responseText += `   Description: ${mod.description}\n`;
+            if (mod.estimatedImpact) {
+                responseText += `   Impact: ${mod.estimatedImpact}\n`;
+            }
+            if (mod.priority) {
+                responseText += `   Priority: ${mod.priority}\n`;
+            }
+            if (mod.tags && mod.tags.length > 0) {
+                responseText += `   Tags: ${mod.tags.join(', ')}\n`;
+            }
+            if (mod.risks) {
+                responseText += `   ⚠️ Risks: ${mod.risks}\n`;
+            }
+            responseText += `\n`;
+        });
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: responseText,
+                },
+            ],
+        };
+    }
+    /**
+     * Handle suggest container modifications
+     */
+    async handleSuggestContainerModifications(args) {
+        const { containerId, categories, includeRisks = true } = args;
+        const result = await modificationService.suggestModifications(containerId, categories, includeRisks);
+        let responseText = `**AI-Powered Modification Suggestions**\n\n`;
+        if (result.recommendations.length > 0) {
+            responseText += `📋 **Recommended Modifications (${result.recommendations.length})**\n\n`;
+            result.recommendations.forEach((rec, index) => {
+                responseText += modificationService.formatRecommendation(rec);
+                responseText += `\n`;
+            });
+        }
+        if (result.alreadyApplied.length > 0) {
+            responseText += `\n✅ **Already Applied (${result.alreadyApplied.length})**\n`;
+            result.alreadyApplied.forEach((id) => {
+                responseText += `- ${id}\n`;
+            });
+        }
+        if (result.notApplicable.length > 0) {
+            responseText += `\n❌ **Not Applicable (${result.notApplicable.length})**\n`;
+            result.notApplicable.forEach((item) => {
+                responseText += `- ${item.name}: ${item.reason}\n`;
+            });
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: responseText,
+                },
+            ],
+        };
+    }
+    /**
+     * Handle apply container modification
+     */
+    async handleApplyContainerModification(args) {
+        const { containerId, modificationId, autoBuild = true, notes } = args;
+        const result = await modificationService.applyModification({
+            containerId,
+            modificationId,
+            autoBuild,
+            notes
+        });
+        let responseText = `**Modification Applied**\n\n`;
+        responseText += `🔄 Application ID: ${result.modificationApplicationId}\n`;
+        responseText += `📊 Status: ${result.status}\n`;
+        responseText += `⏱️ Estimated Completion: ${result.estimatedCompletionTime}\n`;
+        responseText += `🔗 Stream Token: ${result.streamToken}\n\n`;
+        responseText += `Progress notifications will be sent automatically via user-notifications stream.\n`;
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: responseText,
+                },
+            ],
+        };
+    }
+    /**
+     * Handle get modification status
+     */
+    async handleGetModificationStatus(args) {
+        const { containerId, modificationApplicationId } = args;
+        const result = await modificationService.getModificationDetails(containerId, modificationApplicationId);
+        const responseText = modificationService.formatAppliedModification(result);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: responseText,
+                },
+            ],
+        };
+    }
+    /**
+     * Handle list applied modifications
+     */
+    async handleListAppliedModifications(args) {
+        const { containerId, status, limit = 50, offset = 0 } = args;
+        const result = await modificationService.listAppliedModifications(containerId, status, limit, offset);
+        let responseText = `**Applied Modifications**\n\n`;
+        responseText += `Found ${result.count} modification(s)`;
+        if (result.hasMore) {
+            responseText += ` (showing ${result.appliedModifications.length})`;
+        }
+        responseText += `\n\n`;
+        if (result.appliedModifications.length === 0) {
+            responseText += `No modifications have been applied to this container yet.\n`;
+        }
+        else {
+            result.appliedModifications.forEach((mod, index) => {
+                responseText += modificationService.formatAppliedModification(mod);
+                responseText += `\n`;
+            });
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: responseText,
+                },
+            ],
+        };
+    }
     /**
      * Get container development workflow content
      */