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

package/dist/server.js

@@ -1,22 +1,21 @@
 #!/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 { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, ListPromptsRequestSchema, ListResourcesRequestSchema, GetPromptRequestSchema, } from '@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 executionService_js_1 = require("./services/executionService.js");
-const streamingService_js_1 = require("./services/streamingService.js");
-const userNotificationManager_js_1 = require("./services/userNotificationManager.js");
-const userService_js_1 = require("./services/userService.js");
-const errorHandler_js_1 = require("./utils/errorHandler.js");
+import { config } from './config.js';
+import { authManager } from './auth.js';
+import { containerService } from './services/containerService.js';
+import { buildService } from './services/buildService.js';
+import { fileService } from './services/fileService.js';
+import { capabilityService } from './services/capabilityService.js';
+import { executionService } from './services/executionService.js';
+import { importService } from './services/importService.js';
+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 { ErrorHandler } from './utils/errorHandler.js';
 /**
  * 172.ai Container Management MCP Server
  *
@@ -25,13 +24,15 @@ const errorHandler_js_1 = require("./utils/errorHandler.js");
  */
 class ContainerMCPServer {
     constructor() {
-        this.server = new index_js_1.Server({
+        this.server = new Server({
             name: '172ai-containers-mcp-server',
             version: '1.0.0',
         });
         // Initialize MCP server reference for progress notifications
-        buildService_js_1.buildService.setMCPServer(this.server);
-        executionService_js_1.executionService.setMCPServer(this.server);
+        buildService.setMCPServer(this.server);
+        executionService.setMCPServer(this.server);
+        importService.setMCPServer(this.server);
+        exportService.setMCPServer(this.server);
         this.setupTools();
         this.setupErrorHandlers();
         this.initializeStreaming();
@@ -42,7 +43,7 @@ class ContainerMCPServer {
      */
     async initializeStreaming() {
         try {
-            const streamingConfig = config_js_1.config.get('streaming');
+            const streamingConfig = config.get('streaming');
             // Check if user-notifications streaming is enabled
             if (!streamingConfig?.enableUserNotifications) {
                 console.log('[MCP Server] User-notifications streaming disabled via config');
@@ -57,10 +58,10 @@ class ContainerMCPServer {
             console.log('[MCP Server] Initializing user-notifications streaming...');
             // Get current user ID to initialize the notification stream
             try {
-                const userInfo = await userService_js_1.userService.getUserProfile();
+                const userInfo = await userService.getUserProfile();
                 const userId = userInfo.id;
                 console.log(`[MCP Server] Initializing user-notifications for user ${userId}...`);
-                await userNotificationManager_js_1.userNotificationManager.initialize(userId);
+                await userNotificationManager.initialize(userId);
                 console.log('[MCP Server] ✅ User-notifications streaming initialized and ready');
             }
             catch (error) {
@@ -94,19 +95,19 @@ class ContainerMCPServer {
      */
     setupContainerTools() {
         // List containers
-        this.server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => {
+        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
             return {
                 tools: this.getAllTools(),
             };
         });
         // Handle prompts/list requests
-        this.server.setRequestHandler(types_js_1.ListPromptsRequestSchema, async () => {
+        this.server.setRequestHandler(ListPromptsRequestSchema, async () => {
             return {
                 prompts: this.getContainerWorkflowPrompts(),
             };
         });
         // Handle prompts/get requests
-        this.server.setRequestHandler(types_js_1.GetPromptRequestSchema, async (request) => {
+        this.server.setRequestHandler(GetPromptRequestSchema, async (request) => {
             const { name, arguments: args } = request.params;
             switch (name) {
                 case 'container_development_workflow':
@@ -118,16 +119,16 @@ class ContainerMCPServer {
                 case 'container_best_practices':
                     return this.getContainerBestPracticesContent();
                 default:
-                    throw errorHandler_js_1.ErrorHandler.createValidationError(`Unknown prompt: ${name}`);
+                    throw ErrorHandler.createValidationError(`Unknown prompt: ${name}`);
             }
         });
         // Handle resources/list requests
-        this.server.setRequestHandler(types_js_1.ListResourcesRequestSchema, async () => {
+        this.server.setRequestHandler(ListResourcesRequestSchema, async () => {
             return {
                 resources: [],
             };
         });
-        this.server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
             const { name, arguments: args } = request.params;
             try {
                 switch (name) {
@@ -157,6 +158,32 @@ class ContainerMCPServer {
                         return await this.handleCancelBuildMonitoring(args);
                     case 'get_stream_analytics':
                         return await this.handleGetStreamAnalytics(args);
+                    case 'import_container':
+                        return await this.handleImportContainer(args);
+                    case 'get_import_status':
+                        return await this.handleGetImportStatus(args);
+                    case 'list_import_jobs':
+                        return await this.handleListImportJobs(args);
+                    case 'cancel_import_monitoring':
+                        return await this.handleCancelImportMonitoring(args);
+                    case 'get_import_stream_analytics':
+                        return await this.handleGetImportStreamAnalytics(args);
+                    case 'export_container':
+                        return await this.handleExportContainer(args);
+                    case 'get_export_status':
+                        return await this.handleGetExportStatus(args);
+                    case 'list_export_jobs':
+                        return await this.handleListExportJobs(args);
+                    case 'get_export_download_url':
+                        return await this.handleGetExportDownloadUrl(args);
+                    case 'cancel_export_job':
+                        return await this.handleCancelExportJob(args);
+                    case 'cancel_export_monitoring':
+                        return await this.handleCancelExportMonitoring(args);
+                    case 'get_export_stream_analytics':
+                        return await this.handleGetExportStreamAnalytics(args);
+                    case 'get_export_progress_update':
+                        return await this.handleGetExportProgressUpdate(args);
                     case 'list_container_files':
                         return await this.handleListContainerFiles(args);
                     case 'get_file_content':
@@ -210,12 +237,12 @@ class ContainerMCPServer {
                     case 'get_all_progress_updates':
                         return await this.handleGetAllProgressUpdates(args);
                     default:
-                        throw errorHandler_js_1.ErrorHandler.createValidationError(`Unknown tool: ${name}`);
+                        throw ErrorHandler.createValidationError(`Unknown tool: ${name}`);
                 }
             }
             catch (error) {
-                const processedError = errorHandler_js_1.ErrorHandler.processError(error, `Tool: ${name}`);
-                errorHandler_js_1.ErrorHandler.logError(processedError);
+                const processedError = ErrorHandler.processError(error, `Tool: ${name}`);
+                ErrorHandler.logError(processedError);
                 return {
                     content: [
                         {
@@ -738,6 +765,279 @@ Follow same metadata requirements as create_container.`,
                     }
                 }
             },
+            // Import Management Tools
+            {
+                name: 'import_container',
+                description: 'Import a container from Docker Hub or GitHub repository with optional progress tracking',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        sourceType: {
+                            type: 'string',
+                            enum: ['docker', 'git'],
+                            description: 'Source type: "docker" for Docker Hub or "git" for GitHub repository'
+                        },
+                        sourceUrl: {
+                            type: 'string',
+                            description: 'Source URL (e.g., "nginx:latest" for Docker or "https://github.com/user/repo" for Git)'
+                        },
+                        name: {
+                            type: 'string',
+                            description: 'Optional custom name for the imported container'
+                        },
+                        dockerfilePath: {
+                            type: 'string',
+                            description: 'Optional Dockerfile path for Git imports (default: Dockerfile)'
+                        },
+                        dockerHubUsername: {
+                            type: 'string',
+                            description: 'Optional Docker Hub username for private images'
+                        },
+                        dockerHubToken: {
+                            type: 'string',
+                            description: 'Optional Docker Hub access token for private images'
+                        },
+                        progressToken: {
+                            type: 'string',
+                            description: 'Optional token for receiving real-time progress notifications during import'
+                        }
+                    },
+                    required: ['sourceType', 'sourceUrl']
+                }
+            },
+            {
+                name: 'get_import_status',
+                description: 'Get the status of a container import job',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        jobId: {
+                            type: 'string',
+                            description: 'ID of the import job'
+                        }
+                    },
+                    required: ['jobId']
+                }
+            },
+            {
+                name: 'list_import_jobs',
+                description: 'List user\'s container import jobs',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        status: {
+                            type: 'string',
+                            enum: ['pending', 'queued', 'processing', 'completed', 'failed'],
+                            description: 'Filter by import status'
+                        },
+                        limit: {
+                            type: 'number',
+                            minimum: 1,
+                            maximum: 100,
+                            description: 'Maximum number of import jobs to return'
+                        },
+                        offset: {
+                            type: 'number',
+                            minimum: 0,
+                            description: 'Number of import jobs to skip'
+                        }
+                    }
+                }
+            },
+            {
+                name: 'cancel_import_monitoring',
+                description: 'Cancel progress monitoring for a specific import using its progress token',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        progressToken: {
+                            type: 'string',
+                            description: 'Progress token of the import monitoring to cancel'
+                        },
+                        reason: {
+                            type: 'string',
+                            description: 'Optional reason for cancellation'
+                        }
+                    },
+                    required: ['progressToken']
+                }
+            },
+            {
+                name: 'get_import_stream_analytics',
+                description: 'Get real-time analytics and statistics for import streaming operations',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        includeActiveMonitors: {
+                            type: 'boolean',
+                            description: 'Whether to include details of currently active import monitors'
+                        }
+                    }
+                }
+            },
+            // Export Management Tools
+            {
+                name: 'export_container',
+                description: 'Export a container to Docker Hub, GitHub, or as an archive with optional progress tracking',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        containerId: {
+                            type: 'string',
+                            description: 'ID of the container to export'
+                        },
+                        destinationType: {
+                            type: 'string',
+                            enum: ['docker', 'git', 'archive'],
+                            description: 'Export destination type: "docker" for Docker Hub, "git" for GitHub, "archive" for downloadable tar.gz/zip'
+                        },
+                        destination: {
+                            type: 'object',
+                            description: 'Destination configuration (registry/repository/tag for Docker, repositoryName/branch/token for GitHub, format for archive)',
+                            properties: {
+                                registry: { type: 'string', description: 'Docker registry (e.g., docker.io, gcr.io, ghcr.io)' },
+                                repository: { type: 'string', description: 'Docker repository (e.g., username/imagename)' },
+                                tag: { type: 'string', description: 'Docker image tag (e.g., latest, v1.0.0)' },
+                                username: { type: 'string', description: 'Docker Hub username' },
+                                token: { type: 'string', description: 'Docker Hub token/password' },
+                                repositoryName: { type: 'string', description: 'GitHub repository (e.g., username/repo-name)' },
+                                branch: { type: 'string', description: 'GitHub branch (e.g., main, develop)' },
+                                githubToken: { type: 'string', description: 'GitHub Personal Access Token' },
+                                archiveFormat: { type: 'string', enum: ['tar.gz', 'zip'], description: 'Archive format' }
+                            }
+                        },
+                        options: {
+                            type: 'object',
+                            description: 'Export options',
+                            properties: {
+                                includeDockerfile: { type: 'boolean', description: 'Include Dockerfile in export' },
+                                includeMetadata: { type: 'boolean', description: 'Include metadata.json in export' }
+                            }
+                        },
+                        progressToken: {
+                            type: 'string',
+                            description: 'Optional token for receiving real-time progress notifications during export'
+                        }
+                    },
+                    required: ['containerId', 'destinationType', 'destination']
+                }
+            },
+            {
+                name: 'get_export_status',
+                description: 'Get the status of a container export job',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        jobId: {
+                            type: 'string',
+                            description: 'ID of the export job'
+                        }
+                    },
+                    required: ['jobId']
+                }
+            },
+            {
+                name: 'list_export_jobs',
+                description: 'List user\'s container export jobs',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        containerId: {
+                            type: 'string',
+                            description: 'Filter by container ID (optional)'
+                        },
+                        status: {
+                            type: 'string',
+                            enum: ['pending', 'validating', 'building', 'preparing', 'authenticating', 'uploading', 'pushing', 'verifying', 'completed', 'failed', 'cancelled'],
+                            description: 'Filter by export status'
+                        },
+                        limit: {
+                            type: 'number',
+                            minimum: 1,
+                            maximum: 100,
+                            description: 'Maximum number of export jobs to return'
+                        },
+                        offset: {
+                            type: 'number',
+                            minimum: 0,
+                            description: 'Number of export jobs to skip'
+                        }
+                    }
+                }
+            },
+            {
+                name: 'get_export_download_url',
+                description: 'Get download URL for an archive export',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        jobId: {
+                            type: 'string',
+                            description: 'ID of the export job'
+                        }
+                    },
+                    required: ['jobId']
+                }
+            },
+            {
+                name: 'cancel_export_job',
+                description: 'Cancel an in-progress export job',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        jobId: {
+                            type: 'string',
+                            description: 'ID of the export job to cancel'
+                        }
+                    },
+                    required: ['jobId']
+                }
+            },
+            {
+                name: 'cancel_export_monitoring',
+                description: 'Cancel progress monitoring for a specific export using its progress token',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        progressToken: {
+                            type: 'string',
+                            description: 'Progress token of the export monitoring to cancel'
+                        },
+                        reason: {
+                            type: 'string',
+                            description: 'Optional reason for cancellation'
+                        }
+                    },
+                    required: ['progressToken']
+                }
+            },
+            {
+                name: 'get_export_stream_analytics',
+                description: 'Get real-time analytics and statistics for export streaming operations',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        includeActiveMonitors: {
+                            type: 'boolean',
+                            description: 'Whether to include details of currently active export monitors'
+                        }
+                    }
+                }
+            },
+            {
+                name: 'get_export_progress_update',
+                description: 'Get the latest progress update for an export progress token',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        progressToken: {
+                            type: 'string',
+                            description: 'Progress token to check for updates'
+                        }
+                    },
+                    required: ['progressToken']
+                }
+            },
             // File Management Tools
             {
                 name: 'list_container_files',
@@ -1348,23 +1648,23 @@ Follow same metadata requirements as create_container.`,
      */
     setupErrorHandlers() {
         this.server.onerror = (error) => {
-            const processedError = errorHandler_js_1.ErrorHandler.processError(error, 'MCP Server');
-            errorHandler_js_1.ErrorHandler.logError(processedError);
+            const processedError = ErrorHandler.processError(error, 'MCP Server');
+            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);
+            const processedError = ErrorHandler.processError(error, 'Uncaught Exception');
+            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);
+            const processedError = ErrorHandler.processError(reason, 'Unhandled Rejection');
+            ErrorHandler.logError(processedError);
         });
     }
     // Tool handler methods
     async handleListContainers(args) {
-        const result = await containerService_js_1.containerService.listContainers(args);
+        const result = await containerService.listContainers(args);
         return {
             content: [
                 {
@@ -1380,7 +1680,7 @@ Follow same metadata requirements as create_container.`,
         };
     }
     async handleGetContainer(args) {
-        const result = await containerService_js_1.containerService.getContainer(args);
+        const result = await containerService.getContainer(args);
         let response = `**Container: ${result.name}**\n\n` +
             `ID: ${result.id}\n` +
             `Description: ${result.description}\n` +
@@ -1436,7 +1736,7 @@ Follow same metadata requirements as create_container.`,
         };
     }
     async handleCreateContainer(args) {
-        const result = await containerService_js_1.containerService.createContainer(args);
+        const result = await containerService.createContainer(args);
         let response = `Container "${result.name}" created successfully!\n\n` +
             `ID: ${result.id}\n` +
             `Description: ${result.description}\n`;
@@ -1464,7 +1764,7 @@ Follow same metadata requirements as create_container.`,
         };
     }
     async handleUpdateContainer(args) {
-        const result = await containerService_js_1.containerService.updateContainer(args);
+        const result = await containerService.updateContainer(args);
         return {
             content: [
                 {
@@ -1477,7 +1777,7 @@ Follow same metadata requirements as create_container.`,
         };
     }
     async handleDeleteContainer(args) {
-        const result = await containerService_js_1.containerService.deleteContainer(args);
+        const result = await containerService.deleteContainer(args);
         return {
             content: [
                 {
@@ -1488,7 +1788,7 @@ Follow same metadata requirements as create_container.`,
         };
     }
     async handleCopyContainer(args) {
-        const result = await containerService_js_1.containerService.copyContainer(args);
+        const result = await containerService.copyContainer(args);
         return {
             content: [
                 {
@@ -1502,7 +1802,7 @@ Follow same metadata requirements as create_container.`,
     }
     async handleBuildContainer(args) {
         const { progressToken, ...buildParams } = args;
-        const result = await buildService_js_1.buildService.buildContainer(buildParams, progressToken);
+        const result = await buildService.buildContainer(buildParams, progressToken);
         return {
             content: [
                 {
@@ -1517,7 +1817,7 @@ Follow same metadata requirements as create_container.`,
         };
     }
     async handleGetBuildStatus(args) {
-        const result = await buildService_js_1.buildService.getBuildStatus(args);
+        const result = await buildService.getBuildStatus(args);
         return {
             content: [
                 {
@@ -1535,7 +1835,7 @@ Follow same metadata requirements as create_container.`,
         };
     }
     async handleListBuilds(args) {
-        const result = await buildService_js_1.buildService.listBuilds(args);
+        const result = await buildService.listBuilds(args);
         return {
             content: [
                 {
@@ -1551,7 +1851,7 @@ Follow same metadata requirements as create_container.`,
         };
     }
     async handleGetBuildLogs(args) {
-        const result = await buildService_js_1.buildService.getBuildLogs(args.containerId, args.buildId);
+        const result = await buildService.getBuildLogs(args.containerId, args.buildId);
         return {
             content: [
                 {
@@ -1564,7 +1864,7 @@ Follow same metadata requirements as create_container.`,
         };
     }
     async handleExplainBuildLogs(args) {
-        const result = await buildService_js_1.buildService.explainBuildLogs(args.containerId, args.buildId, {
+        const result = await buildService.explainBuildLogs(args.containerId, args.buildId, {
             verbosity: args.verbosity,
             outputFormat: args.outputFormat,
             includeRecommendations: args.includeRecommendations,
@@ -1589,7 +1889,7 @@ Follow same metadata requirements as create_container.`,
         };
     }
     async handleCancelBuildMonitoring(args) {
-        const success = await buildService_js_1.buildService.cancelBuildMonitoring(args.progressToken, args.reason);
+        const success = await buildService.cancelBuildMonitoring(args.progressToken, args.reason);
         return {
             content: [
                 {
@@ -1602,7 +1902,7 @@ Follow same metadata requirements as create_container.`,
         };
     }
     async handleGetStreamAnalytics(args) {
-        const analytics = buildService_js_1.buildService.getStreamAnalytics();
+        const analytics = buildService.getStreamAnalytics();
         const includeMonitors = args.includeActiveMonitors !== false; // Default to true
         let analyticsText = `**Build Streaming Analytics**\n\n` +
             `📊 **Overview**\n` +
@@ -1639,8 +1939,347 @@ Follow same metadata requirements as create_container.`,
             ],
         };
     }
+    // Import handler methods
+    async handleImportContainer(args) {
+        const { progressToken, ...importParams } = args;
+        const result = await importService.importContainer(importParams, progressToken);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Container import started successfully!\n\n` +
+                        `Job ID: ${result.jobId}\n` +
+                        `Source Type: ${result.sourceType}\n` +
+                        `Source URL: ${result.sourceUrl}\n` +
+                        `Status: ${result.status}\n` +
+                        `${result.tokenCost ? `Token Cost: ${result.tokenCost}\n` : ''}` +
+                        `${result.estimatedDuration ? `Estimated Duration: ${result.estimatedDuration}\n` : ''}` +
+                        `Created: ${result.createdAt}\n` +
+                        `${progressToken ? `\n🔄 Progress updates will be sent via notifications using token: ${progressToken}` : ''}`,
+                },
+            ],
+        };
+    }
+    async handleGetImportStatus(args) {
+        const result = await importService.getImportStatus(args.jobId);
+        let statusText = `**Import Job Status**\n\n` +
+            `Job ID: ${result.jobId}\n` +
+            `Status: ${result.status}\n` +
+            `Source Type: ${result.sourceType}\n` +
+            `Source URL: ${result.sourceUrl}\n` +
+            `Created: ${result.createdAt}\n` +
+            `${result.updatedAt ? `Updated: ${result.updatedAt}\n` : ''}` +
+            `${result.completedAt ? `Completed: ${result.completedAt}\n` : ''}`;
+        if (result.progress) {
+            statusText += `\n**Progress**\n` +
+                `Step: ${result.progress.step} (${result.progress.stepNumber}/${result.progress.totalSteps})\n` +
+                `Message: ${result.progress.message}\n`;
+        }
+        if (result.containerId) {
+            statusText += `\n✅ **Container Created**: ${result.containerId}\n`;
+        }
+        if (result.errors && result.errors.length > 0) {
+            statusText += `\n❌ **Errors**:\n${result.errors.map(e => `  • ${e}`).join('\n')}\n`;
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: statusText,
+                },
+            ],
+        };
+    }
+    async handleListImportJobs(args) {
+        const result = await importService.listImportJobs(args);
+        let listText = `**Import Jobs** (${result.imports.length} found)\n\n`;
+        if (result.imports.length === 0) {
+            listText += `No import jobs found.\n`;
+        }
+        else {
+            result.imports.forEach((job, index) => {
+                listText += `${index + 1}. **${job.jobId}**\n` +
+                    `   • Status: ${job.status}\n` +
+                    `   • Source: ${job.sourceType} - ${job.sourceUrl}\n` +
+                    `   • Created: ${job.createdAt}\n` +
+                    `   ${job.containerId ? `• Container: ${job.containerId}\n` : ''}` +
+                    `   ${job.errors && job.errors.length > 0 ? `• Errors: ${job.errors.length}\n` : ''}\n`;
+            });
+        }
+        if (result.pagination) {
+            listText += `\n**Pagination**\n` +
+                `• Showing: ${result.pagination.offset + 1}-${Math.min(result.pagination.offset + result.pagination.limit, result.pagination.total)}\n` +
+                `• Total: ${result.pagination.total}\n` +
+                `• Has More: ${result.pagination.hasMore ? 'Yes' : 'No'}\n`;
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: listText,
+                },
+            ],
+        };
+    }
+    async handleCancelImportMonitoring(args) {
+        const success = await importService.cancelImportMonitoring(args.progressToken, args.reason);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: success
+                        ? `✅ Import monitoring cancelled for progress token: ${args.progressToken}\n${args.reason ? `Reason: ${args.reason}` : ''}`
+                        : `❌ No active monitoring found for progress token: ${args.progressToken}`,
+                },
+            ],
+        };
+    }
+    async handleGetImportStreamAnalytics(args) {
+        const analytics = importService.getStreamAnalytics();
+        const includeMonitors = args.includeActiveMonitors !== false; // Default to true
+        let analyticsText = `**Import Streaming Analytics**\n\n` +
+            `📊 **Overview**\n` +
+            `• Total Imports: ${analytics.totalImports}\n` +
+            `• Active Imports: ${analytics.activeImports}\n` +
+            `• Completed Imports: ${analytics.completedImports}\n` +
+            `• Failed Imports: ${analytics.failedImports}\n` +
+            `• Average Import Time: ${Math.round(analytics.averageImportTime / 1000)}s\n` +
+            `• Notifications Sent: ${analytics.notificationsSent}\n` +
+            `• Errors Encountered: ${analytics.errorsEncountered}\n` +
+            `• Last Activity: ${analytics.lastActivity}\n`;
+        if (includeMonitors && analytics.activeStreams?.length > 0) {
+            analyticsText += `\n🔄 **Active Monitors (${analytics.activeStreams.length})**\n`;
+            analytics.activeStreams.forEach((stream, index) => {
+                const elapsed = Math.round((Date.now() - stream.startTime) / 1000);
+                analyticsText += `${index + 1}. **${stream.jobId}**\n` +
+                    `   • Source Type: ${stream.sourceType}\n` +
+                    `   • Source URL: ${stream.sourceUrl}\n` +
+                    `   • Progress Token: ${stream.progressToken}\n` +
+                    `   • Status: ${stream.status}\n` +
+                    `   • Progress: ${stream.lastProgress}%\n` +
+                    `   • Elapsed: ${elapsed}s\n\n`;
+            });
+        }
+        else if (includeMonitors) {
+            analyticsText += `\n✅ **No Active Monitors**\n`;
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: analyticsText,
+                },
+            ],
+        };
+    }
+    // Export Handler Methods
+    async handleExportContainer(args) {
+        const { progressToken, ...exportParams } = args;
+        const result = await exportService.exportContainer(exportParams, progressToken);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Container export started successfully!\n\n` +
+                        `Job ID: ${result.jobId}\n` +
+                        `Container: ${result.containerName}\n` +
+                        `Destination Type: ${result.destinationType}\n` +
+                        `Status: ${result.status}\n` +
+                        `Token Cost: ${result.tokenCost}\n` +
+                        `${result.estimatedDuration ? `Estimated Duration: ${result.estimatedDuration}\n` : ''}` +
+                        `Created: ${result.createdAt}\n` +
+                        `${progressToken ? `\n🔄 Progress updates will be sent via notifications using token: ${progressToken}` : ''}`,
+                },
+            ],
+        };
+    }
+    async handleGetExportStatus(args) {
+        const result = await exportService.getExportStatus(args.jobId);
+        let statusText = `**Export Job Status**\n\n` +
+            `Job ID: ${result.jobId}\n` +
+            `Container: ${result.containerName}\n` +
+            `Status: ${result.status}\n` +
+            `Destination Type: ${result.destinationType}\n` +
+            `Token Cost: ${result.tokenCost}\n` +
+            `Created: ${result.createdAt}\n` +
+            `${result.updatedAt ? `Updated: ${result.updatedAt}\n` : ''}` +
+            `${result.completedAt ? `Completed: ${result.completedAt}\n` : ''}`;
+        if (result.progress) {
+            statusText += `\n**Progress**\n` +
+                `Stage: ${result.progress.stage} (${result.progress.stageNumber}/${result.progress.totalStages})\n` +
+                `Progress: ${result.progress.percent}%\n` +
+                `Message: ${result.progress.message}\n`;
+        }
+        if (result.result) {
+            statusText += `\n✅ **Export Result**:\n`;
+            if (result.result.imageUrl) {
+                statusText += `  • Image URL: ${result.result.imageUrl}\n`;
+                statusText += `  • Digest: ${result.result.digest || 'N/A'}\n`;
+                statusText += `  • Registry: ${result.result.registry || 'N/A'}\n`;
+            }
+            if (result.result.repositoryUrl) {
+                statusText += `  • Repository: ${result.result.repositoryUrl}\n`;
+                statusText += `  • Branch: ${result.result.branch || 'N/A'}\n`;
+                statusText += `  • Commit: ${result.result.commit || 'N/A'}\n`;
+            }
+            if (result.result.downloadUrl) {
+                statusText += `  • Download URL: ${result.result.downloadUrl}\n`;
+                statusText += `  • Expires: ${result.result.expiresAt || 'N/A'}\n`;
+                statusText += `  • Format: ${result.result.format || 'N/A'}\n`;
+            }
+        }
+        if (result.errors && result.errors.length > 0) {
+            statusText += `\n❌ **Errors**:\n${result.errors.map(e => `  • ${e}`).join('\n')}\n`;
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: statusText,
+                },
+            ],
+        };
+    }
+    async handleListExportJobs(args) {
+        const result = await exportService.listExportJobs(args);
+        let listText = `**Export Jobs** (${result.exports.length} found)\n\n`;
+        if (result.exports.length === 0) {
+            listText += `No export jobs found.\n`;
+        }
+        else {
+            result.exports.forEach((job, index) => {
+                listText += `${index + 1}. **${job.jobId}**\n` +
+                    `   • Container: ${job.containerName}\n` +
+                    `   • Status: ${job.status}\n` +
+                    `   • Destination: ${job.destinationType}\n` +
+                    `   • Progress: ${job.progress.percent}%\n` +
+                    `   • Created: ${job.createdAt}\n` +
+                    `   ${job.errors && job.errors.length > 0 ? `• Errors: ${job.errors.length}\n` : ''}\n`;
+            });
+        }
+        if (result.pagination) {
+            listText += `\n**Pagination**\n` +
+                `• Showing: ${result.pagination.offset + 1}-${Math.min(result.pagination.offset + result.pagination.limit, result.pagination.total)}\n` +
+                `• Total: ${result.pagination.total}\n` +
+                `• Has More: ${result.pagination.hasMore ? 'Yes' : 'No'}\n`;
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: listText,
+                },
+            ],
+        };
+    }
+    async handleGetExportDownloadUrl(args) {
+        const result = await exportService.getExportDownloadUrl(args.jobId);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `**Export Download URL**\n\n` +
+                        `Download URL: ${result.downloadUrl}\n` +
+                        `Expires: ${result.expiresAt}\n` +
+                        `Format: ${result.format}\n` +
+                        `Size: ${result.size} bytes\n`,
+                },
+            ],
+        };
+    }
+    async handleCancelExportJob(args) {
+        const result = await exportService.cancelExportJob(args.jobId);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `✅ Export job cancelled\n\n` +
+                        `Job ID: ${result.jobId}\n` +
+                        `Status: ${result.status}\n` +
+                        `Updated: ${result.updatedAt}`,
+                },
+            ],
+        };
+    }
+    async handleCancelExportMonitoring(args) {
+        const success = await exportService.cancelExportMonitoring(args.progressToken, args.reason);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: success
+                        ? `✅ Export monitoring cancelled for progress token: ${args.progressToken}\n${args.reason ? `Reason: ${args.reason}` : ''}`
+                        : `❌ No active monitoring found for progress token: ${args.progressToken}`,
+                },
+            ],
+        };
+    }
+    async handleGetExportStreamAnalytics(args) {
+        const analytics = exportService.getStreamAnalytics();
+        const includeMonitors = args.includeActiveMonitors !== false; // Default to true
+        let analyticsText = `**Export Streaming Analytics**\n\n` +
+            `📊 **Overview**\n` +
+            `• Total Exports: ${analytics.totalExports}\n` +
+            `• Active Exports: ${analytics.activeExports}\n` +
+            `• Completed Exports: ${analytics.completedExports}\n` +
+            `• Failed Exports: ${analytics.failedExports}\n` +
+            `• Average Export Time: ${Math.round(analytics.averageExportTime / 1000)}s\n` +
+            `• Notifications Sent: ${analytics.notificationsSent}\n` +
+            `• Errors Encountered: ${analytics.errorsEncountered}\n` +
+            `• Last Activity: ${analytics.lastActivity}\n`;
+        if (includeMonitors && analytics.activeStreams?.length > 0) {
+            analyticsText += `\n🔄 **Active Monitors (${analytics.activeStreams.length})**\n`;
+            analytics.activeStreams.forEach((stream, index) => {
+                const elapsed = Math.round((Date.now() - stream.startTime) / 1000);
+                analyticsText += `${index + 1}. **${stream.jobId}**\n` +
+                    `   • Container: ${stream.containerName}\n` +
+                    `   • Destination: ${stream.destinationType}\n` +
+                    `   • Progress Token: ${stream.progressToken}\n` +
+                    `   • Status: ${stream.status}\n` +
+                    `   • Progress: ${stream.lastProgress}%\n` +
+                    `   • Elapsed: ${elapsed}s\n\n`;
+            });
+        }
+        else if (includeMonitors) {
+            analyticsText += `\n✅ **No Active Monitors**\n`;
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: analyticsText,
+                },
+            ],
+        };
+    }
+    async handleGetExportProgressUpdate(args) {
+        const update = exportService.getProgressUpdate(args.progressToken);
+        if (!update) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `No progress update available for token: ${args.progressToken}`,
+                    },
+                ],
+            };
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `**Export Progress Update**\n\n` +
+                        `Progress Token: ${args.progressToken}\n` +
+                        `Status: ${update.status || 'unknown'}\n` +
+                        `Progress: ${update.progress || 0}%\n` +
+                        `Message: ${update.message || 'No message'}\n` +
+                        `Timestamp: ${update.timestamp || new Date().toISOString()}`,
+                },
+            ],
+        };
+    }
     async handleListContainerFiles(args) {
-        const result = await fileService_js_1.fileService.listContainerFiles(args);
+        const result = await fileService.listContainerFiles(args);
         return {
             content: [
                 {
@@ -1655,7 +2294,7 @@ Follow same metadata requirements as create_container.`,
         };
     }
     async handleGetFileContent(args) {
-        const result = await fileService_js_1.fileService.getFileContent(args);
+        const result = await fileService.getFileContent(args);
         return {
             content: [
                 {
@@ -1671,7 +2310,7 @@ Follow same metadata requirements as create_container.`,
         };
     }
     async handleUploadFile(args) {
-        const result = await fileService_js_1.fileService.uploadFile(args);
+        const result = await fileService.uploadFile(args);
         return {
             content: [
                 {
@@ -1686,7 +2325,7 @@ Follow same metadata requirements as create_container.`,
         };
     }
     async handleUpdateFile(args) {
-        const result = await fileService_js_1.fileService.updateFile(args);
+        const result = await fileService.updateFile(args);
         return {
             content: [
                 {
@@ -1701,7 +2340,7 @@ Follow same metadata requirements as create_container.`,
         };
     }
     async handleDeleteFile(args) {
-        const result = await fileService_js_1.fileService.deleteFile(args.containerId, args.filePath);
+        const result = await fileService.deleteFile(args.containerId, args.filePath);
         return {
             content: [
                 {
@@ -1712,7 +2351,7 @@ Follow same metadata requirements as create_container.`,
         };
     }
     async handleListCapabilities(args) {
-        const result = await capabilityService_js_1.capabilityService.listCapabilities(args);
+        const result = await capabilityService.listCapabilities(args);
         return {
             content: [
                 {
@@ -1728,7 +2367,7 @@ Follow same metadata requirements as create_container.`,
         };
     }
     async handleGetCapability(args) {
-        const result = await capabilityService_js_1.capabilityService.getCapability(args);
+        const result = await capabilityService.getCapability(args);
         return {
             content: [
                 {
@@ -1746,7 +2385,7 @@ Follow same metadata requirements as create_container.`,
         };
     }
     async handleSearchCapabilities(args) {
-        const result = await capabilityService_js_1.capabilityService.searchCapabilities(args.query, args.category, args.limit);
+        const result = await capabilityService.searchCapabilities(args.query, args.category, args.limit);
         return {
             content: [
                 {
@@ -1762,7 +2401,7 @@ Follow same metadata requirements as create_container.`,
     // Execution handler methods
     async handleStartExecution(args) {
         const { progressToken, ...executionParams } = args;
-        const result = await executionService_js_1.executionService.startExecution(executionParams, progressToken);
+        const result = await executionService.startExecution(executionParams, progressToken);
         return {
             content: [
                 {
@@ -1781,7 +2420,7 @@ Follow same metadata requirements as create_container.`,
         };
     }
     async handleStopExecution(args) {
-        const result = await executionService_js_1.executionService.stopExecution(args);
+        const result = await executionService.stopExecution(args);
         return {
             content: [
                 {
@@ -1794,7 +2433,7 @@ Follow same metadata requirements as create_container.`,
         };
     }
     async handleGetExecutionStatus(args) {
-        const result = await executionService_js_1.executionService.getExecutionStatus(args);
+        const result = await executionService.getExecutionStatus(args);
         return {
             content: [
                 {
@@ -1816,7 +2455,7 @@ Follow same metadata requirements as create_container.`,
         };
     }
     async handleListExecutions(args) {
-        const result = await executionService_js_1.executionService.listExecutions(args);
+        const result = await executionService.listExecutions(args);
         return {
             content: [
                 {
@@ -1837,7 +2476,7 @@ Follow same metadata requirements as create_container.`,
         };
     }
     async handleGetExecutionProgress(args) {
-        const result = await executionService_js_1.executionService.getExecutionProgress(args);
+        const result = await executionService.getExecutionProgress(args);
         return {
             content: [
                 {
@@ -1855,7 +2494,7 @@ Follow same metadata requirements as create_container.`,
         };
     }
     async handleGetExecutionLogs(args) {
-        const result = await executionService_js_1.executionService.getExecutionLogs(args);
+        const result = await executionService.getExecutionLogs(args);
         // Format logs properly - handle both string logs and log objects
         const formatLog = (log, index) => {
             if (typeof log === 'string') {
@@ -1892,7 +2531,7 @@ Follow same metadata requirements as create_container.`,
         };
     }
     async handleExplainRuntimeLogs(args) {
-        const result = await executionService_js_1.executionService.explainRuntimeLogs(args.executionId, {
+        const result = await executionService.explainRuntimeLogs(args.executionId, {
             verbosity: args.verbosity,
             outputFormat: args.outputFormat,
             includeContext: args.includeContext,
@@ -1917,7 +2556,7 @@ Follow same metadata requirements as create_container.`,
         };
     }
     async handleExplainDeploymentLogs(args) {
-        const result = await executionService_js_1.executionService.explainDeploymentLogs(args.executionId, {
+        const result = await executionService.explainDeploymentLogs(args.executionId, {
             verbosity: args.verbosity,
             outputFormat: args.outputFormat,
             includeContext: args.includeContext,
@@ -1941,7 +2580,7 @@ Follow same metadata requirements as create_container.`,
         };
     }
     async handleExtendExecution(args) {
-        const result = await executionService_js_1.executionService.extendExecution(args);
+        const result = await executionService.extendExecution(args);
         return {
             content: [
                 {
@@ -1954,7 +2593,7 @@ Follow same metadata requirements as create_container.`,
         };
     }
     async handleGetExecutionHistory(args) {
-        const result = await executionService_js_1.executionService.getExecutionHistory(args.containerId, args.limit);
+        const result = await executionService.getExecutionHistory(args.containerId, args.limit);
         return {
             content: [
                 {
@@ -1974,7 +2613,7 @@ Follow same metadata requirements as create_container.`,
         };
     }
     async handleGetCostEstimate(args) {
-        const result = await executionService_js_1.executionService.getCostEstimate(args);
+        const result = await executionService.getCostEstimate(args);
         return {
             content: [
                 {
@@ -1998,7 +2637,7 @@ Follow same metadata requirements as create_container.`,
         };
     }
     async handleGetExtensionCostEstimate(args) {
-        const result = await executionService_js_1.executionService.getExtensionCostEstimate(args);
+        const result = await executionService.getExtensionCostEstimate(args);
         return {
             content: [
                 {
@@ -2021,7 +2660,7 @@ Follow same metadata requirements as create_container.`,
         };
     }
     async handleGetContainerMetrics(args) {
-        const metrics = await executionService_js_1.executionService.getExecutionMetrics(args);
+        const metrics = await executionService.getExecutionMetrics(args);
         const formatMetric = (value, unit = '') => {
             return value !== null ? `${value}${unit}` : 'N/A';
         };
@@ -2059,7 +2698,7 @@ Follow same metadata requirements as create_container.`,
         };
     }
     async handleCancelExecutionMonitoring(args) {
-        const success = await executionService_js_1.executionService.cancelExecutionMonitoring(args.progressToken, args.reason);
+        const success = await executionService.cancelExecutionMonitoring(args.progressToken, args.reason);
         return {
             content: [
                 {
@@ -2072,7 +2711,7 @@ Follow same metadata requirements as create_container.`,
         };
     }
     async handleGetExecutionStreamAnalytics(args) {
-        const analytics = executionService_js_1.executionService.getExecutionStreamAnalytics();
+        const analytics = executionService.getExecutionStreamAnalytics();
         const includeMonitors = args.includeActiveMonitors !== false; // Default to true
         let analyticsText = `**Execution Streaming Analytics**\n\n` +
             `📊 **Overview**\n` +
@@ -2115,9 +2754,9 @@ Follow same metadata requirements as create_container.`,
     async handleGetBuildProgressUpdate(args) {
         const { progressToken } = args;
         if (!progressToken) {
-            throw errorHandler_js_1.ErrorHandler.createValidationError('Progress token is required');
+            throw ErrorHandler.createValidationError('Progress token is required');
         }
-        const progressUpdate = buildService_js_1.buildService.getProgressUpdate(progressToken);
+        const progressUpdate = buildService.getProgressUpdate(progressToken);
         if (!progressUpdate) {
             return {
                 content: [
@@ -2148,9 +2787,9 @@ Follow same metadata requirements as create_container.`,
     async handleGetExecutionProgressUpdate(args) {
         const { progressToken } = args;
         if (!progressToken) {
-            throw errorHandler_js_1.ErrorHandler.createValidationError('Progress token is required');
+            throw ErrorHandler.createValidationError('Progress token is required');
         }
-        const progressUpdate = executionService_js_1.executionService.getProgressUpdate(progressToken);
+        const progressUpdate = executionService.getProgressUpdate(progressToken);
         if (!progressUpdate) {
             return {
                 content: [
@@ -2179,8 +2818,8 @@ Follow same metadata requirements as create_container.`,
      * Get all progress updates for debugging
      */
     async handleGetAllProgressUpdates(args) {
-        const buildUpdates = buildService_js_1.buildService.getAllProgressUpdates();
-        const executionUpdates = executionService_js_1.executionService.getAllProgressUpdates();
+        const buildUpdates = buildService.getAllProgressUpdates();
+        const executionUpdates = executionService.getAllProgressUpdates();
         let responseText = `**All Progress Updates**\n\n`;
         const buildTokens = Object.keys(buildUpdates);
         const executionTokens = Object.keys(executionUpdates);
@@ -2735,24 +3374,24 @@ Follow these best practices to create robust, secure, and efficient containerize
         try {
             // Test authentication
             console.error('🔑 Testing authentication...');
-            const isAuthenticated = await auth_js_1.authManager.testAuthentication();
+            const isAuthenticated = await 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();
+            const transport = new StdioServerTransport();
             await this.server.connect(transport);
             // Set up graceful shutdown to cleanup streaming connections
             process.on('SIGINT', () => this.shutdown('SIGINT'));
             process.on('SIGTERM', () => this.shutdown('SIGTERM'));
             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(`📋 Configuration: ${config.get('baseUrl')} (${config.get('environment')})`);
             console.error('🔧 Available tools: container management, builds, files, capabilities, executions');
         }
         catch (error) {
-            const processedError = errorHandler_js_1.ErrorHandler.processError(error, 'Server startup');
-            errorHandler_js_1.ErrorHandler.logError(processedError);
+            const processedError = ErrorHandler.processError(error, 'Server startup');
+            ErrorHandler.logError(processedError);
             console.error('❌ Failed to start MCP server:', processedError.message);
             process.exit(1);
         }
@@ -2764,7 +3403,7 @@ Follow these best practices to create robust, secure, and efficient containerize
         console.error(`[MCP Server] Received ${signal}, shutting down gracefully...`);
         try {
             // Disconnect from all streaming channels
-            await streamingService_js_1.streamingService.disconnect();
+            await streamingService.disconnect();
             console.error('[MCP Server] ✅ Streaming connections closed');
             // Close server
             await this.server.close();
@@ -2777,5 +3416,6 @@ Follow these best practices to create robust, secure, and efficient containerize
         }
     }
 }
-exports.ContainerMCPServer = ContainerMCPServer;
+// Note: Server startup is now handled by cli.ts
+export { ContainerMCPServer };
 //# sourceMappingURL=server.js.map