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

package/dist/server.js

@@ -10,6 +10,8 @@ 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';
@@ -29,6 +31,8 @@ class ContainerMCPServer {
         // Initialize MCP server reference for progress notifications
         buildService.setMCPServer(this.server);
         executionService.setMCPServer(this.server);
+        importService.setMCPServer(this.server);
+        exportService.setMCPServer(this.server);
         this.setupTools();
         this.setupErrorHandlers();
         this.initializeStreaming();
@@ -154,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':
@@ -735,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',
@@ -1636,6 +1939,345 @@ 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.listContainerFiles(args);
         return {