@172ai/containers-mcp-server 1.0.0

package/dist/server.js

@@ -0,0 +1,886 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContainerMCPServer = void 0;
+const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+// Import our services and utilities
+const config_js_1 = require("./config.js");
+const auth_js_1 = require("./auth.js");
+const containerService_js_1 = require("./services/containerService.js");
+const buildService_js_1 = require("./services/buildService.js");
+const fileService_js_1 = require("./services/fileService.js");
+const capabilityService_js_1 = require("./services/capabilityService.js");
+const errorHandler_js_1 = require("./utils/errorHandler.js");
+/**
+ * 172.ai Container Management MCP Server
+ *
+ * Provides AI assistants with access to container management functionality
+ * through the Model Context Protocol (MCP).
+ */
+class ContainerMCPServer {
+    constructor() {
+        this.server = new index_js_1.Server({
+            name: '172ai-containers-mcp-server',
+            version: '1.0.0',
+        });
+        this.setupTools();
+        this.setupErrorHandlers();
+    }
+    /**
+     * Set up all available tools
+     */
+    setupTools() {
+        // Container Management Tools
+        this.setupContainerTools();
+        // Build Management Tools
+        this.setupBuildTools();
+        // File Management Tools
+        this.setupFileTools();
+        // Capability Management Tools
+        this.setupCapabilityTools();
+    }
+    /**
+     * Set up container management tools
+     */
+    setupContainerTools() {
+        // List containers
+        this.server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => {
+            return {
+                tools: this.getAllTools(),
+            };
+        });
+        this.server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+            const { name, arguments: args } = request.params;
+            try {
+                switch (name) {
+                    case 'list_containers':
+                        return await this.handleListContainers(args);
+                    case 'get_container':
+                        return await this.handleGetContainer(args);
+                    case 'create_container':
+                        return await this.handleCreateContainer(args);
+                    case 'update_container':
+                        return await this.handleUpdateContainer(args);
+                    case 'delete_container':
+                        return await this.handleDeleteContainer(args);
+                    case 'copy_container':
+                        return await this.handleCopyContainer(args);
+                    case 'build_container':
+                        return await this.handleBuildContainer(args);
+                    case 'get_build_status':
+                        return await this.handleGetBuildStatus(args);
+                    case 'list_builds':
+                        return await this.handleListBuilds(args);
+                    case 'get_build_logs':
+                        return await this.handleGetBuildLogs(args);
+                    case 'list_container_files':
+                        return await this.handleListContainerFiles(args);
+                    case 'get_file_content':
+                        return await this.handleGetFileContent(args);
+                    case 'upload_file':
+                        return await this.handleUploadFile(args);
+                    case 'update_file':
+                        return await this.handleUpdateFile(args);
+                    case 'delete_file':
+                        return await this.handleDeleteFile(args);
+                    case 'list_capabilities':
+                        return await this.handleListCapabilities(args);
+                    case 'get_capability':
+                        return await this.handleGetCapability(args);
+                    case 'search_capabilities':
+                        return await this.handleSearchCapabilities(args);
+                    default:
+                        throw errorHandler_js_1.ErrorHandler.createValidationError(`Unknown tool: ${name}`);
+                }
+            }
+            catch (error) {
+                const processedError = errorHandler_js_1.ErrorHandler.processError(error, `Tool: ${name}`);
+                errorHandler_js_1.ErrorHandler.logError(processedError);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Error: ${processedError.message}`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+        });
+    }
+    /**
+     * Get all available tools
+     */
+    getAllTools() {
+        return [
+            // Container Management Tools
+            {
+                name: 'list_containers',
+                description: 'List available containers with optional filtering',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        scope: {
+                            type: 'string',
+                            enum: ['public', 'myCollection', 'all'],
+                            description: 'Filter containers by scope'
+                        },
+                        limit: {
+                            type: 'number',
+                            minimum: 1,
+                            maximum: 100,
+                            description: 'Maximum number of containers to return'
+                        },
+                        offset: {
+                            type: 'number',
+                            minimum: 0,
+                            description: 'Number of containers to skip'
+                        },
+                        query: {
+                            type: 'string',
+                            description: 'Search query to filter containers'
+                        }
+                    }
+                }
+            },
+            {
+                name: 'get_container',
+                description: 'Get detailed information about a specific container',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        containerId: {
+                            type: 'string',
+                            description: 'ID of the container to retrieve'
+                        }
+                    },
+                    required: ['containerId']
+                }
+            },
+            {
+                name: 'create_container',
+                description: 'Create a new container template',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        name: {
+                            type: 'string',
+                            description: 'Name of the container'
+                        },
+                        description: {
+                            type: 'string',
+                            description: 'Description of the container'
+                        },
+                        dockerfile: {
+                            type: 'string',
+                            description: 'Dockerfile content'
+                        },
+                        tags: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'Tags for the container'
+                        },
+                        isPrivate: {
+                            type: 'boolean',
+                            description: 'Whether the container is private'
+                        },
+                        envVars: {
+                            type: 'object',
+                            additionalProperties: { type: 'string' },
+                            description: 'Environment variables'
+                        }
+                    },
+                    required: ['name', 'description', 'dockerfile']
+                }
+            },
+            {
+                name: 'update_container',
+                description: 'Update an existing container configuration',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        containerId: {
+                            type: 'string',
+                            description: 'ID of the container to update'
+                        },
+                        name: {
+                            type: 'string',
+                            description: 'New name for the container'
+                        },
+                        description: {
+                            type: 'string',
+                            description: 'New description for the container'
+                        },
+                        dockerfile: {
+                            type: 'string',
+                            description: 'New Dockerfile content'
+                        },
+                        tags: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'New tags for the container'
+                        },
+                        isPrivate: {
+                            type: 'boolean',
+                            description: 'Whether the container should be private'
+                        },
+                        envVars: {
+                            type: 'object',
+                            additionalProperties: { type: 'string' },
+                            description: 'New environment variables'
+                        }
+                    },
+                    required: ['containerId']
+                }
+            },
+            {
+                name: 'delete_container',
+                description: 'Delete a container',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        containerId: {
+                            type: 'string',
+                            description: 'ID of the container to delete'
+                        }
+                    },
+                    required: ['containerId']
+                }
+            },
+            {
+                name: 'copy_container',
+                description: 'Create a copy of an existing container',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        containerId: {
+                            type: 'string',
+                            description: 'ID of the container to copy'
+                        },
+                        newName: {
+                            type: 'string',
+                            description: 'Name for the new container'
+                        }
+                    },
+                    required: ['containerId', 'newName']
+                }
+            },
+            // Build Management Tools
+            {
+                name: 'build_container',
+                description: 'Start building a container',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        containerId: {
+                            type: 'string',
+                            description: 'ID of the container to build'
+                        },
+                        buildArgs: {
+                            type: 'object',
+                            additionalProperties: { type: 'string' },
+                            description: 'Build arguments'
+                        },
+                        target: {
+                            type: 'string',
+                            description: 'Build target stage'
+                        }
+                    },
+                    required: ['containerId']
+                }
+            },
+            {
+                name: 'get_build_status',
+                description: 'Get the status of a container build',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        containerId: {
+                            type: 'string',
+                            description: 'ID of the container'
+                        },
+                        buildId: {
+                            type: 'string',
+                            description: 'ID of the specific build (optional, gets latest if not provided)'
+                        }
+                    },
+                    required: ['containerId']
+                }
+            },
+            {
+                name: 'list_builds',
+                description: 'List builds for a container or all builds',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        containerId: {
+                            type: 'string',
+                            description: 'ID of the container (optional, lists all builds if not provided)'
+                        },
+                        status: {
+                            type: 'string',
+                            enum: ['pending', 'running', 'completed', 'failed', 'cancelled'],
+                            description: 'Filter by build status'
+                        },
+                        limit: {
+                            type: 'number',
+                            minimum: 1,
+                            maximum: 100,
+                            description: 'Maximum number of builds to return'
+                        },
+                        offset: {
+                            type: 'number',
+                            minimum: 0,
+                            description: 'Number of builds to skip'
+                        }
+                    }
+                }
+            },
+            {
+                name: 'get_build_logs',
+                description: 'Get build logs for a container',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        containerId: {
+                            type: 'string',
+                            description: 'ID of the container'
+                        },
+                        buildId: {
+                            type: 'string',
+                            description: 'ID of the specific build (optional, gets latest if not provided)'
+                        }
+                    },
+                    required: ['containerId']
+                }
+            },
+            // File Management Tools
+            {
+                name: 'list_container_files',
+                description: 'List files in a container',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        containerId: {
+                            type: 'string',
+                            description: 'ID of the container'
+                        },
+                        path: {
+                            type: 'string',
+                            description: 'Path within the container (optional, defaults to root)'
+                        }
+                    },
+                    required: ['containerId']
+                }
+            },
+            {
+                name: 'get_file_content',
+                description: 'Get the content of a file in a container',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        containerId: {
+                            type: 'string',
+                            description: 'ID of the container'
+                        },
+                        filePath: {
+                            type: 'string',
+                            description: 'Path to the file within the container'
+                        }
+                    },
+                    required: ['containerId', 'filePath']
+                }
+            },
+            {
+                name: 'upload_file',
+                description: 'Upload a file to a container',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        containerId: {
+                            type: 'string',
+                            description: 'ID of the container'
+                        },
+                        filePath: {
+                            type: 'string',
+                            description: 'Path where the file should be uploaded'
+                        },
+                        content: {
+                            type: 'string',
+                            description: 'Content of the file'
+                        },
+                        mimeType: {
+                            type: 'string',
+                            description: 'MIME type of the file'
+                        },
+                        encoding: {
+                            type: 'string',
+                            enum: ['utf8', 'base64'],
+                            description: 'Encoding of the content'
+                        }
+                    },
+                    required: ['containerId', 'filePath', 'content']
+                }
+            },
+            {
+                name: 'update_file',
+                description: 'Update the content of an existing file in a container',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        containerId: {
+                            type: 'string',
+                            description: 'ID of the container'
+                        },
+                        filePath: {
+                            type: 'string',
+                            description: 'Path to the file within the container'
+                        },
+                        content: {
+                            type: 'string',
+                            description: 'New content of the file'
+                        },
+                        mimeType: {
+                            type: 'string',
+                            description: 'MIME type of the file'
+                        },
+                        encoding: {
+                            type: 'string',
+                            enum: ['utf8', 'base64'],
+                            description: 'Encoding of the content'
+                        }
+                    },
+                    required: ['containerId', 'filePath', 'content']
+                }
+            },
+            {
+                name: 'delete_file',
+                description: 'Delete a file from a container',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        containerId: {
+                            type: 'string',
+                            description: 'ID of the container'
+                        },
+                        filePath: {
+                            type: 'string',
+                            description: 'Path to the file within the container'
+                        }
+                    },
+                    required: ['containerId', 'filePath']
+                }
+            },
+            // Capability Management Tools
+            {
+                name: 'list_capabilities',
+                description: 'List available capabilities',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        category: {
+                            type: 'string',
+                            description: 'Filter capabilities by category'
+                        },
+                        limit: {
+                            type: 'number',
+                            minimum: 1,
+                            maximum: 100,
+                            description: 'Maximum number of capabilities to return'
+                        },
+                        offset: {
+                            type: 'number',
+                            minimum: 0,
+                            description: 'Number of capabilities to skip'
+                        },
+                        query: {
+                            type: 'string',
+                            description: 'Search query to filter capabilities'
+                        }
+                    }
+                }
+            },
+            {
+                name: 'get_capability',
+                description: 'Get detailed information about a specific capability',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        capabilityId: {
+                            type: 'string',
+                            description: 'ID of the capability to retrieve'
+                        }
+                    },
+                    required: ['capabilityId']
+                }
+            },
+            {
+                name: 'search_capabilities',
+                description: 'Search capabilities by name or description',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        query: {
+                            type: 'string',
+                            description: 'Search query'
+                        },
+                        category: {
+                            type: 'string',
+                            description: 'Filter by category'
+                        },
+                        limit: {
+                            type: 'number',
+                            minimum: 1,
+                            maximum: 100,
+                            description: 'Maximum number of results'
+                        }
+                    },
+                    required: ['query']
+                }
+            }
+        ];
+    }
+    /**
+     * Set up build management tools handlers
+     */
+    setupBuildTools() {
+        // Build tools are handled in the main CallToolRequestSchema handler
+    }
+    /**
+     * Set up file management tools handlers
+     */
+    setupFileTools() {
+        // File tools are handled in the main CallToolRequestSchema handler
+    }
+    /**
+     * Set up capability management tools handlers
+     */
+    setupCapabilityTools() {
+        // Capability tools are handled in the main CallToolRequestSchema handler
+    }
+    /**
+     * Set up error handlers
+     */
+    setupErrorHandlers() {
+        this.server.onerror = (error) => {
+            const processedError = errorHandler_js_1.ErrorHandler.processError(error, 'MCP Server');
+            errorHandler_js_1.ErrorHandler.logError(processedError);
+        };
+        // Handle uncaught exceptions
+        process.on('uncaughtException', (error) => {
+            const processedError = errorHandler_js_1.ErrorHandler.processError(error, 'Uncaught Exception');
+            errorHandler_js_1.ErrorHandler.logError(processedError);
+            process.exit(1);
+        });
+        process.on('unhandledRejection', (reason) => {
+            const processedError = errorHandler_js_1.ErrorHandler.processError(reason, 'Unhandled Rejection');
+            errorHandler_js_1.ErrorHandler.logError(processedError);
+        });
+    }
+    // Tool handler methods
+    async handleListContainers(args) {
+        const result = await containerService_js_1.containerService.listContainers(args);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Found ${result.containers.length} containers (${result.total} total):\n\n` +
+                        result.containers.map(c => `**${c.name}** (${c.id})\n` +
+                            `Description: ${c.description}\n` +
+                            `Tags: ${c.tags?.join(', ') || 'None'}\n` +
+                            `Private: ${c.isPrivate ? 'Yes' : 'No'}\n` +
+                            `Created: ${c.createdAt}\n`).join('\n'),
+                },
+            ],
+        };
+    }
+    async handleGetContainer(args) {
+        const result = await containerService_js_1.containerService.getContainer(args);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `**Container: ${result.name}**\n\n` +
+                        `ID: ${result.id}\n` +
+                        `Description: ${result.description}\n` +
+                        `Tags: ${result.tags?.join(', ') || 'None'}\n` +
+                        `Private: ${result.isPrivate ? 'Yes' : 'No'}\n` +
+                        `Created: ${result.createdAt}\n` +
+                        `Updated: ${result.updatedAt}\n\n` +
+                        `**Dockerfile:**\n\`\`\`dockerfile\n${result.dockerfile}\n\`\`\`\n\n` +
+                        `**Environment Variables:**\n${Object.entries(result.envVars || {}).map(([k, v]) => `${k}=${v}`).join('\n') || 'None'}`,
+                },
+            ],
+        };
+    }
+    async handleCreateContainer(args) {
+        const result = await containerService_js_1.containerService.createContainer(args);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Container "${result.name}" created successfully!\n\n` +
+                        `ID: ${result.id}\n` +
+                        `Description: ${result.description}\n` +
+                        `Created: ${result.createdAt}`,
+                },
+            ],
+        };
+    }
+    async handleUpdateContainer(args) {
+        const result = await containerService_js_1.containerService.updateContainer(args);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Container "${result.name}" updated successfully!\n\n` +
+                        `ID: ${result.id}\n` +
+                        `Updated: ${result.updatedAt}`,
+                },
+            ],
+        };
+    }
+    async handleDeleteContainer(args) {
+        const result = await containerService_js_1.containerService.deleteContainer(args);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: result.message,
+                },
+            ],
+        };
+    }
+    async handleCopyContainer(args) {
+        const result = await containerService_js_1.containerService.copyContainer(args);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Container copied successfully!\n\n` +
+                        `New container: "${result.name}" (${result.id})\n` +
+                        `Created: ${result.createdAt}`,
+                },
+            ],
+        };
+    }
+    async handleBuildContainer(args) {
+        const result = await buildService_js_1.buildService.buildContainer(args);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Build started for container ${args.containerId}!\n\n` +
+                        `Build ID: ${result.id}\n` +
+                        `Status: ${result.status}\n` +
+                        `Started: ${result.startTime}`,
+                },
+            ],
+        };
+    }
+    async handleGetBuildStatus(args) {
+        const result = await buildService_js_1.buildService.getBuildStatus(args);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `**Build Status**\n\n` +
+                        `Build ID: ${result.id}\n` +
+                        `Container: ${result.containerId}\n` +
+                        `Status: ${result.status}\n` +
+                        `Started: ${result.startTime}\n` +
+                        `${result.endTime ? `Ended: ${result.endTime}\n` : ''}` +
+                        `${result.progress ? `Progress: ${result.progress}%\n` : ''}` +
+                        `${result.error ? `Error: ${result.error}\n` : ''}`,
+                },
+            ],
+        };
+    }
+    async handleListBuilds(args) {
+        const result = await buildService_js_1.buildService.listBuilds(args);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Found ${result.builds.length} builds (${result.total} total):\n\n` +
+                        result.builds.map(b => `**Build ${b.id}**\n` +
+                            `Container: ${b.containerId}\n` +
+                            `Status: ${b.status}\n` +
+                            `Started: ${b.startTime}\n` +
+                            `${b.endTime ? `Ended: ${b.endTime}\n` : ''}\n`).join('\n'),
+                },
+            ],
+        };
+    }
+    async handleGetBuildLogs(args) {
+        const result = await buildService_js_1.buildService.getBuildLogs(args.containerId, args.buildId);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: result.length === 0 ? 'No build logs available yet.' :
+                        `**Build Logs**\n\n` +
+                            result.map(log => `[${log.timestamp}] ${log.level.toUpperCase()}: ${log.message}`).join('\n'),
+                },
+            ],
+        };
+    }
+    async handleListContainerFiles(args) {
+        const result = await fileService_js_1.fileService.listContainerFiles(args);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Files in ${result.path} (${result.total} total):\n\n` +
+                        result.files.map(f => `${f.type === 'directory' ? '📁' : '📄'} **${f.name}**\n` +
+                            `Path: ${f.path}\n` +
+                            `${f.size ? `Size: ${f.size} bytes\n` : ''}` +
+                            `${f.lastModified ? `Modified: ${f.lastModified}\n` : ''}\n`).join('\n'),
+                },
+            ],
+        };
+    }
+    async handleGetFileContent(args) {
+        const result = await fileService_js_1.fileService.getFileContent(args);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `**File: ${result.name}**\n\n` +
+                        `Path: ${result.path}\n` +
+                        `${result.size ? `Size: ${result.size} bytes\n` : ''}` +
+                        `${result.mimeType ? `Type: ${result.mimeType}\n` : ''}` +
+                        `${result.lastModified ? `Modified: ${result.lastModified}\n` : ''}\n\n` +
+                        `**Content:**\n\`\`\`\n${result.content || 'No content available'}\n\`\`\``,
+                },
+            ],
+        };
+    }
+    async handleUploadFile(args) {
+        const result = await fileService_js_1.fileService.uploadFile(args);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `File uploaded successfully!\n\n` +
+                        `Path: ${result.path}\n` +
+                        `Name: ${result.name}\n` +
+                        `Size: ${result.size} bytes\n` +
+                        `Uploaded: ${result.uploadedAt}`,
+                },
+            ],
+        };
+    }
+    async handleUpdateFile(args) {
+        const result = await fileService_js_1.fileService.updateFile(args);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `File updated successfully!\n\n` +
+                        `Path: ${result.path}\n` +
+                        `Name: ${result.name}\n` +
+                        `${result.size ? `Size: ${result.size} bytes\n` : ''}` +
+                        `${result.lastModified ? `Modified: ${result.lastModified}` : ''}`,
+                },
+            ],
+        };
+    }
+    async handleDeleteFile(args) {
+        const result = await fileService_js_1.fileService.deleteFile(args.containerId, args.filePath);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: result.message,
+                },
+            ],
+        };
+    }
+    async handleListCapabilities(args) {
+        const result = await capabilityService_js_1.capabilityService.listCapabilities(args);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Found ${result.capabilities.length} capabilities (${result.total} total):\n\n` +
+                        result.capabilities.map(c => `**${c.name}** (${c.id})\n` +
+                            `Description: ${c.description}\n` +
+                            `Category: ${c.category}\n` +
+                            `Version: ${c.version}\n` +
+                            `Active: ${c.isActive ? 'Yes' : 'No'}\n\n`).join(''),
+                },
+            ],
+        };
+    }
+    async handleGetCapability(args) {
+        const result = await capabilityService_js_1.capabilityService.getCapability(args);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `**Capability: ${result.name}**\n\n` +
+                        `ID: ${result.id}\n` +
+                        `Description: ${result.description}\n` +
+                        `Category: ${result.category}\n` +
+                        `Version: ${result.version}\n` +
+                        `Active: ${result.isActive ? 'Yes' : 'No'}\n` +
+                        `${result.dependencies?.length ? `Dependencies: ${result.dependencies.join(', ')}\n` : ''}` +
+                        `${result.configuration ? `Configuration: ${JSON.stringify(result.configuration, null, 2)}` : ''}`,
+                },
+            ],
+        };
+    }
+    async handleSearchCapabilities(args) {
+        const result = await capabilityService_js_1.capabilityService.searchCapabilities(args.query, args.category, args.limit);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Search results for "${args.query}" (${result.length} found):\n\n` +
+                        result.map(c => `**${c.name}** (${c.id})\n` +
+                            `Description: ${c.description}\n` +
+                            `Category: ${c.category}\n\n`).join(''),
+                },
+            ],
+        };
+    }
+    /**
+     * Start the MCP server
+     */
+    async start() {
+        try {
+            // Test authentication
+            console.error('🔑 Testing authentication...');
+            const isAuthenticated = await auth_js_1.authManager.testAuthentication();
+            if (!isAuthenticated) {
+                throw new Error('Authentication failed. Please check your API credentials.');
+            }
+            console.error('✅ Authentication successful');
+            // Start the server
+            const transport = new stdio_js_1.StdioServerTransport();
+            await this.server.connect(transport);
+            console.error('🚀 172.ai Container MCP Server started successfully');
+            console.error(`📋 Configuration: ${config_js_1.config.get('baseUrl')} (${config_js_1.config.get('environment')})`);
+            console.error('🔧 Available tools: container management, builds, files, capabilities');
+        }
+        catch (error) {
+            const processedError = errorHandler_js_1.ErrorHandler.processError(error, 'Server startup');
+            errorHandler_js_1.ErrorHandler.logError(processedError);
+            console.error('❌ Failed to start MCP server:', processedError.message);
+            process.exit(1);
+        }
+    }
+}
+exports.ContainerMCPServer = ContainerMCPServer;
+// Start the server if this file is run directly
+if (require.main === module) {
+    const server = new ContainerMCPServer();
+    server.start().catch((error) => {
+        console.error('Fatal error:', error);
+        process.exit(1);
+    });
+}
+//# sourceMappingURL=server.js.map