@docker-digital/dockernet-agent 0.1.3 → 0.1.6

package/dist/apps/agent/src/agent/services/profile.service.js

@@ -0,0 +1,1300 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var ProfileService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProfileService = void 0;
+const common_1 = require("@nestjs/common");
+const fs = require("fs-extra");
+const path = require("path");
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const api_service_1 = require("./api.service");
+const config_service_1 = require("./config.service");
+const docker_service_1 = require("./docker.service");
+const docker_event_service_1 = require("./docker-event.service");
+const log_service_1 = require("./log.service");
+const websocket_client_service_1 = require("./websocket-client.service");
+const utils_1 = require("../../../../../shared/common/utils");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+function wrapDockerCommand(cmd) {
+    const originalUser = process.env.SUDO_USER;
+    if (originalUser) {
+        const escapedCmd = cmd.replace(/'/g, "'\\''");
+        return `sudo -u ${originalUser} sh -c '${escapedCmd}'`;
+    }
+    return cmd;
+}
+let ProfileService = ProfileService_1 = class ProfileService {
+    constructor(apiService, configService, dockerService, dockerEventService, logService, websocketClientService) {
+        this.apiService = apiService;
+        this.configService = configService;
+        this.dockerService = dockerService;
+        this.dockerEventService = dockerEventService;
+        this.logService = logService;
+        this.websocketClientService = websocketClientService;
+        this.logger = new common_1.Logger(ProfileService_1.name);
+        this.useEventDrivenUpdates = false;
+    }
+    async onModuleInit() {
+        this.dockerEventService.onContainerStateChangedCallback((event) => this.handleContainerStateChanged(event));
+    }
+    async initializeWebSocket() {
+        try {
+            await this.websocketClientService.connect();
+            if (this.websocketClientService.isWebSocketConnected()) {
+                this.useEventDrivenUpdates = true;
+                utils_1.cliLogger.block({
+                    title: 'Event-driven status updates enabled (WebSocket connected)',
+                    context: 'ProfileService',
+                    func: 'initializeWebSocket',
+                    type: 'info',
+                    metadata: {},
+                });
+            }
+            else {
+                utils_1.cliLogger.block({
+                    title: 'WebSocket not available, falling back to polling',
+                    context: 'ProfileService',
+                    func: 'initializeWebSocket',
+                    type: 'warning',
+                    metadata: {},
+                });
+            }
+        }
+        catch (error) {
+            this.logger.warn(`Failed to connect WebSocket: ${error.message}, using polling fallback`);
+        }
+    }
+    async getProfileDetails(profileId) {
+        let endpoint = `/docker-profiles/${profileId}`;
+        this.logger.debug(`Calling API: GET ${endpoint}`);
+        const maxRetries = 24;
+        const response = (await this.apiService.callApi('GET', endpoint, undefined, maxRetries, 5000));
+        utils_1.cliLogger.block({
+            title: 'API response received',
+            context: 'ProfileService',
+            func: 'getProfileDetails',
+            type: 'debug',
+            metadata: {
+                response: response ? 'success' : 'null',
+            },
+        });
+        if (!response) {
+            utils_1.cliLogger.block({
+                title: 'No response from API for profile',
+                context: 'ProfileService',
+                func: 'getProfileDetails',
+                type: 'warning',
+                metadata: {
+                    profileId: profileId,
+                },
+            });
+            return null;
+        }
+        const responseData = response.data || response;
+        if (!responseData) {
+            utils_1.cliLogger.block({
+                title: 'No data in API response for profile',
+                context: 'ProfileService',
+                func: 'getProfileDetails',
+                type: 'warning',
+                metadata: {
+                    profileId: profileId,
+                },
+            });
+            return null;
+        }
+        if (responseData.profile) {
+            const profile = responseData.profile;
+            if (responseData.docker_compose_content) {
+                profile.docker_compose_content = responseData.docker_compose_content;
+                profile.dockerComposeContent = responseData.docker_compose_content;
+            }
+            if (responseData.services) {
+                profile.services_status = responseData.services;
+                profile.servicesStatus = responseData.services;
+            }
+            utils_1.cliLogger.block({
+                title: 'Profile parsed with docker_compose_content',
+                context: 'ProfileService',
+                func: 'getProfileDetails',
+                type: 'debug',
+                metadata: {
+                    profile: profile ? 'success' : 'null',
+                },
+            });
+            return profile;
+        }
+        utils_1.cliLogger.block({
+            title: 'Profile parsed',
+            context: 'ProfileService',
+            func: 'getProfileDetails',
+            type: 'debug',
+            metadata: {
+                responseData: responseData ? 'success' : 'null',
+            },
+        });
+        return responseData;
+    }
+    async getProfilesByMachineKey() {
+        const machineKey = await this.configService.getMachineKey();
+        if (!machineKey) {
+            utils_1.cliLogger.block({
+                title: 'Machine key not found, cannot fetch profiles',
+                context: 'ProfileService',
+                func: 'getProfilesByMachineKey',
+                type: 'warning',
+                metadata: {},
+            });
+            return [];
+        }
+        try {
+            const endpoint = `/docker-profiles?machine_key=${machineKey}`;
+            const profilesResponse = await this.apiService.callApi('GET', endpoint, undefined, 3, 5000);
+            if (!profilesResponse) {
+                return [];
+            }
+            const profiles = profilesResponse.rows || [];
+            utils_1.cliLogger.block({
+                title: `Fetched ${profiles.length} profile(s) for machine`,
+                context: 'ProfileService',
+                func: 'getProfilesByMachineKey',
+                type: 'info',
+                metadata: { machineKey, profileCount: profiles.length },
+            });
+            return profiles;
+        }
+        catch (error) {
+            utils_1.cliLogger.block({
+                title: `Error fetching profiles: ${error.message}`,
+                context: 'ProfileService',
+                func: 'getProfilesByMachineKey',
+                type: 'error',
+                metadata: { error: error.message },
+            });
+            return [];
+        }
+    }
+    async startProfile(eventKey, profileId, workspaceId) {
+        utils_1.cliLogger.startProcess(`Starting profile: ${profileId}`, '🚀');
+        if (!profileId) {
+            utils_1.cliLogger.error('Profile ID is required');
+            return;
+        }
+        if (!workspaceId || workspaceId === 'null' || workspaceId === 'undefined') {
+            utils_1.cliLogger.error('Workspace ID is required');
+        }
+        this.logger.log(`Starting profile: ${profileId}, workspace: ${workspaceId}`);
+        this.logger.log(`[DEBUG] After Starting profile log, about to fetch profile details`);
+        utils_1.cliLogger.step(1, 5, 'Fetching profile details...');
+        this.logger.log(`[DEBUG] Calling getProfileDetails for ${profileId}`);
+        const profile = await this.getProfileDetails(profileId);
+        utils_1.cliLogger.block({
+            title: 'getProfileDetails returned',
+            context: 'ProfileService',
+            func: 'startProfile',
+            type: 'debug',
+            metadata: {
+                profile: profile ? 'success' : 'null',
+            },
+        });
+        if (!profile) {
+            utils_1.cliLogger.error('Cannot get profile details from server');
+            utils_1.cliLogger.block({
+                title: 'Cannot get profile details from server',
+                context: 'ProfileService',
+                func: 'startProfile',
+                type: 'error',
+                metadata: {
+                    profileId: profileId,
+                },
+            });
+            await this.websocketClientService.sendStatusUpdate({
+                type: 'profile_update',
+                workspace_id: workspaceId,
+                profile_key: profileId,
+                status: 'failed',
+                error: 'Cannot get profile details from server',
+                timestamp: Date.now(),
+            });
+            return;
+        }
+        utils_1.cliLogger.block({
+            title: 'Profile details retrieved successfully',
+            context: 'ProfileService',
+            func: 'startProfile',
+            type: 'debug',
+            metadata: {
+                profileId: profileId,
+            },
+        });
+        const machineKey = await this.configService.getMachineKey();
+        const profileMachineKey = profile.machine_key;
+        if (profileMachineKey && profileMachineKey !== machineKey) {
+            utils_1.cliLogger.block({
+                title: 'Skipping profile - machine_key mismatch',
+                context: 'ProfileService',
+                func: 'startProfile',
+                type: 'warning',
+                metadata: {
+                    profileId: profileId,
+                    profileMachineKey: profileMachineKey,
+                    machineKey: machineKey,
+                },
+            });
+            return;
+        }
+        const deployPath = profile.deploy_path ||
+            profile.deployPath ||
+            '/opt/docker-compose';
+        utils_1.cliLogger.block({
+            title: 'Using deploy_path',
+            context: 'ProfileService',
+            func: 'startProfile',
+            type: 'debug',
+            metadata: {
+                deployPath: deployPath,
+            },
+        });
+        utils_1.cliLogger.step(2, 5, 'Creating profile directory and files...');
+        this.logger.log(`[DEBUG] Creating deploy_path directory: ${deployPath}`);
+        await fs.ensureDir(deployPath);
+        const profileDir = path.join(this.configService.workDirPath, profileId);
+        await fs.ensureDir(profileDir);
+        utils_1.cliLogger.block({
+            title: 'Profile directory created',
+            context: 'ProfileService',
+            func: 'startProfile',
+            type: 'debug',
+            metadata: {
+                profileDir: profileDir,
+            },
+        });
+        const envContent = profile.env_content || profile.envContent || '';
+        const envFile = path.join(deployPath, `.env_${profileId}`);
+        utils_1.cliLogger.block({
+            title: 'Env content length',
+            context: 'ProfileService',
+            func: 'startProfile',
+            type: 'debug',
+            metadata: {
+                envContentLength: envContent?.length || 0,
+            },
+        });
+        utils_1.cliLogger.block({
+            title: 'Profile keys',
+            context: 'ProfileService',
+            func: 'startProfile',
+            type: 'debug',
+            metadata: {
+                profileKeys: Object.keys(profile).join(', '),
+            },
+        });
+        await fs.writeFile(envFile, envContent || '');
+        utils_1.cliLogger.block({
+            title: 'Created .env file in deployPath',
+            context: 'ProfileService',
+            func: 'startProfile',
+            type: 'debug',
+            metadata: {
+                envFile: envFile,
+                deployPath: deployPath,
+                hasContent: !!envContent && envContent.length > 0,
+                contentLength: envContent?.length || 0,
+            },
+        });
+        if (!envContent || envContent.length === 0) {
+            utils_1.cliLogger.block({
+                title: '.env file created but empty (no env_content in profile)',
+                context: 'ProfileService',
+                func: 'startProfile',
+                type: 'info',
+                metadata: {
+                    profileId: profileId,
+                },
+            });
+        }
+        const dockerComposeContent = profile.docker_compose_content ||
+            profile.dockerComposeContent ||
+            profile.data?.docker_compose_content ||
+            profile.data?.dockerComposeContent;
+        if (!dockerComposeContent) {
+            utils_1.cliLogger.error('Profile does not have docker-compose content');
+            await this.websocketClientService.sendStatusUpdate({
+                type: 'profile_update',
+                workspace_id: workspaceId,
+                profile_key: profileId,
+                status: 'failed',
+                error: 'Profile does not have docker-compose content',
+                timestamp: Date.now(),
+            });
+            return;
+        }
+        await this.handlePrivateRegistries(profile);
+        const composeFile = path.join(deployPath, `docker-compose_${profileId}.yaml`);
+        await fs.writeFile(composeFile, dockerComposeContent);
+        utils_1.cliLogger.success('Files created successfully');
+        utils_1.cliLogger.block({
+            title: 'Created docker-compose file',
+            context: 'ProfileService',
+            func: 'startProfile',
+            type: 'debug',
+            metadata: {
+                composeFile: composeFile,
+            },
+        });
+        utils_1.cliLogger.step(3, 5, 'Starting Docker containers...');
+        utils_1.cliLogger.block({
+            title: 'Executing docker-compose up',
+            context: 'ProfileService',
+            func: 'startProfile',
+            type: 'debug',
+            metadata: {
+                profileId: profileId,
+            },
+        });
+        try {
+            await this.handlePrivateRegistries(profile);
+            const envFile = path.join(deployPath, `.env_${profileId}`);
+            let composeCommand = `docker-compose -p "${profileId}" -f "${composeFile}"`;
+            if (fs.existsSync(envFile)) {
+                composeCommand += ` --env-file "${envFile}"`;
+                utils_1.cliLogger.block({
+                    title: 'Using .env file',
+                    context: 'ProfileService',
+                    func: 'startProfile',
+                    type: 'debug',
+                    metadata: {
+                        envFile: envFile,
+                        deployPath: deployPath,
+                        hasContent: !!envContent && envContent.length > 0,
+                    },
+                });
+            }
+            else {
+                utils_1.cliLogger.block({
+                    title: '.env file not found (unexpected)',
+                    context: 'ProfileService',
+                    func: 'startProfile',
+                    type: 'warning',
+                    metadata: {
+                        profileId: profileId,
+                        envFile: envFile,
+                    },
+                });
+            }
+            composeCommand += ` up -d`;
+            const finalCommand = wrapDockerCommand(composeCommand);
+            utils_1.cliLogger.block({
+                title: 'Docker compose command',
+                context: 'ProfileService',
+                func: 'startProfile',
+                type: 'debug',
+                metadata: {
+                    command: finalCommand,
+                },
+            });
+            const { stdout, stderr } = await execAsync(finalCommand, {
+                cwd: deployPath,
+            });
+            utils_1.cliLogger.block({
+                title: 'Docker compose up stdout',
+                context: 'ProfileService',
+                func: 'startProfile',
+                type: 'debug',
+                metadata: {
+                    stdout: stdout,
+                },
+            });
+            if (stderr && !stderr.includes('Creating')) {
+                utils_1.cliLogger.block({
+                    title: 'Docker compose warnings',
+                    context: 'ProfileService',
+                    func: 'startProfile',
+                    type: 'warning',
+                    metadata: {
+                        stderr: stderr,
+                    },
+                });
+            }
+            utils_1.cliLogger.block({
+                title: 'Docker compose up completed successfully',
+                context: 'ProfileService',
+                func: 'startProfile',
+                type: 'success',
+                metadata: {
+                    profileId: profileId,
+                },
+            });
+            utils_1.cliLogger.success('Docker containers started');
+        }
+        catch (error) {
+            utils_1.cliLogger.error(`Docker compose up failed: ${error.message}`);
+            utils_1.cliLogger.block({
+                title: 'Docker compose up failed',
+                context: 'ProfileService',
+                func: 'startProfile',
+                type: 'error',
+                metadata: {
+                    profileId: profileId,
+                    error: error.message,
+                },
+            });
+            utils_1.cliLogger.block({
+                title: 'Error details',
+                context: 'ProfileService',
+                func: 'startProfile',
+                type: 'error',
+                metadata: {
+                    error: error,
+                },
+            });
+            try {
+                if (fs.existsSync(composeFile)) {
+                    await fs.remove(composeFile);
+                    utils_1.cliLogger.block({
+                        title: 'Removed docker-compose file',
+                        context: 'ProfileService',
+                        func: 'startProfile',
+                        type: 'debug',
+                        metadata: {
+                            composeFile: composeFile,
+                        },
+                    });
+                }
+                const envFile = path.join(deployPath, `.env_${profileId}`);
+                if (fs.existsSync(envFile)) {
+                    await fs.remove(envFile);
+                    utils_1.cliLogger.block({
+                        title: 'Removed .env file',
+                        context: 'ProfileService',
+                        func: 'startProfile',
+                        type: 'debug',
+                        metadata: {
+                            envFile: envFile,
+                            deployPath: deployPath,
+                        },
+                    });
+                }
+                const files = await fs.readdir(profileDir);
+                if (files.length === 0) {
+                    await fs.remove(profileDir);
+                    utils_1.cliLogger.block({
+                        title: 'Removed empty profile directory',
+                        context: 'ProfileService',
+                        func: 'startProfile',
+                        type: 'debug',
+                        metadata: {
+                            profileDir: profileDir,
+                        },
+                    });
+                }
+                utils_1.cliLogger.block({
+                    title: 'Cleanup completed',
+                    context: 'ProfileService',
+                    func: 'startProfile',
+                    type: 'success',
+                    metadata: {
+                        profileId: profileId,
+                    },
+                });
+            }
+            catch (cleanupError) {
+                utils_1.cliLogger.block({
+                    title: 'Cleanup failed',
+                    context: 'ProfileService',
+                    func: 'startProfile',
+                    type: 'error',
+                    metadata: {
+                        error: cleanupError.message,
+                    },
+                });
+            }
+            await this.websocketClientService.sendStatusUpdate({
+                type: 'profile_update',
+                workspace_id: workspaceId,
+                profile_key: profileId,
+                status: 'failed',
+                error: `docker compose up failed: ${error.message}`,
+                timestamp: Date.now(),
+            });
+            return;
+        }
+        utils_1.cliLogger.step(4, 5, 'Starting log streaming...');
+        await this.logService.startLogStreamsForProfile(profileId);
+        utils_1.cliLogger.block({
+            title: 'Log streaming started',
+            context: 'ProfileService',
+            func: 'startProfile',
+            type: 'success',
+            metadata: {
+                profileId: profileId,
+            },
+        });
+        utils_1.cliLogger.step(5, 5, 'Saving profile metadata...');
+        const metadataFile = path.join(profileDir, '.profile_metadata');
+        await fs.writeFile(metadataFile, `workspace_id=${workspaceId}\nprofile_id=${profileId}\n`);
+        utils_1.cliLogger.block({
+            title: 'Metadata saved',
+            context: 'ProfileService',
+            func: 'startProfile',
+            type: 'success',
+            metadata: {
+                profileId: profileId,
+            },
+        });
+        await this.updateProfileStatus(profileId, workspaceId, true);
+        await this.websocketClientService.sendStatusUpdate({
+            type: 'profile_update',
+            workspace_id: workspaceId,
+            profile_key: profileId,
+            status: 'active',
+            timestamp: Date.now(),
+        });
+        utils_1.cliLogger.completeProcess(`Profile ${profileId} started successfully!`, {
+            'Profile ID': profileId,
+            'Workspace ID': workspaceId,
+            'Deploy Path': deployPath,
+            'Compose File': composeFile,
+        });
+        utils_1.cliLogger.block({
+            title: 'Profile started successfully',
+            context: 'ProfileService',
+            func: 'startProfile',
+            type: 'success',
+            metadata: {
+                profileId: profileId,
+            },
+        });
+    }
+    async stopProfile(eventKey, profileId, workspaceId) {
+        utils_1.cliLogger.block({
+            title: 'Stopping profile',
+            context: 'ProfileService',
+            func: 'stopProfile',
+            type: 'info',
+            metadata: {
+                profileId: profileId,
+                workspaceId: workspaceId || null
+            },
+        });
+        if (!profileId) {
+            utils_1.cliLogger.block({
+                title: 'Profile ID is required',
+                context: 'ProfileService',
+                func: 'stopProfile',
+                type: 'error',
+                metadata: {
+                    profileId: profileId,
+                    workspaceId: workspaceId || null
+                },
+            });
+            return;
+        }
+        this.logger.log(`Stopping profile: ${profileId}`);
+        let deployPath = '/opt/docker-compose';
+        if (workspaceId && workspaceId !== 'null' && workspaceId !== 'undefined') {
+            const profile = await this.getProfileDetails(profileId);
+            if (profile) {
+                deployPath =
+                    profile.deploy_path ||
+                        profile.deployPath ||
+                        '/opt/docker-compose';
+                const machineKey = await this.configService.getMachineKey();
+                const profileMachineKey = profile.machine_key;
+                if (profileMachineKey && profileMachineKey !== machineKey) {
+                    utils_1.cliLogger.block({
+                        title: 'Skipping profile - machine_key mismatch',
+                        context: 'ProfileService',
+                        func: 'stopProfile',
+                        type: 'warning',
+                        metadata: {
+                            profileId: profileId,
+                        },
+                    });
+                }
+            }
+        }
+        else {
+            const profile = await this.getProfileDetails(profileId);
+            if (profile) {
+                deployPath =
+                    profile.deploy_path ||
+                        profile.deployPath ||
+                        '/opt/docker-compose';
+            }
+        }
+        utils_1.cliLogger.block({
+            title: 'Using deploy_path for stop',
+            context: 'ProfileService',
+            func: 'stopProfile',
+            type: 'debug',
+            metadata: {
+                deployPath: deployPath,
+            },
+        });
+        const composeFile = path.join(deployPath, `docker-compose_${profileId}.yaml`);
+        if (!fs.existsSync(composeFile)) {
+            utils_1.cliLogger.block({
+                title: 'Docker-compose file not found',
+                context: 'ProfileService',
+                func: 'stopProfile',
+                type: 'error',
+                metadata: {
+                    profileId: profileId,
+                },
+            });
+            return;
+        }
+        utils_1.cliLogger.step(1, 2, 'Stopping log streams...');
+        await this.logService.stopLogStreamsForProfile(profileId);
+        utils_1.cliLogger.success('Log streams stopped');
+        utils_1.cliLogger.step(2, 2, 'Stopping Docker containers (docker-compose stop)...');
+        try {
+            const stopCommand = wrapDockerCommand(`docker-compose -p "${profileId}" -f "${composeFile}" stop`);
+            await execAsync(stopCommand, {
+                cwd: deployPath,
+            });
+            utils_1.cliLogger.success('Docker containers stopped (stopped state, not removed)');
+        }
+        catch (error) {
+            utils_1.cliLogger.error(`docker compose stop failed: ${error.message}`);
+            await this.markEventFailed(eventKey, `docker compose stop failed: ${error.message}`);
+            return;
+        }
+        if (workspaceId && workspaceId !== 'null' && workspaceId !== 'undefined') {
+            await this.updateProfileStatus(profileId, workspaceId, false);
+        }
+        utils_1.cliLogger.block({
+            title: 'Profile stopped successfully',
+            context: 'ProfileService',
+            func: 'stopProfile',
+            type: 'success',
+            metadata: {
+                profileId: profileId,
+            },
+        });
+    }
+    async restartService(eventKey, profileId, workspaceId, serviceName) {
+        utils_1.cliLogger.block({
+            title: 'Restarting service',
+            context: 'ProfileService',
+            func: 'restartService',
+            type: 'info',
+            metadata: {
+                profileId: profileId,
+                serviceName: serviceName,
+            },
+        });
+        const profile = await this.getProfileDetails(profileId);
+        const deployPath = profile?.deploy_path ||
+            profile?.deployPath ||
+            '/opt/docker-compose';
+        utils_1.cliLogger.block({
+            title: 'Using deploy_path for restart',
+            context: 'ProfileService',
+            func: 'restartService',
+            type: 'debug',
+            metadata: {
+                deployPath: deployPath,
+            },
+        });
+        const composeFile = path.join(deployPath, `docker-compose_${profileId}.yaml`);
+        if (!fs.existsSync(composeFile)) {
+            utils_1.cliLogger.block({
+                title: 'Docker-compose file not found',
+                context: 'ProfileService',
+                func: 'restartService',
+                type: 'error',
+                metadata: {
+                    profileId: profileId,
+                    serviceName: serviceName,
+                    composeFile: composeFile,
+                },
+            });
+            return;
+        }
+        try {
+            utils_1.cliLogger.step(1, 1, `Restarting service ${serviceName}...`);
+            const restartCommand = wrapDockerCommand(`docker-compose -p "${profileId}" -f "${composeFile}" restart ${serviceName}`);
+            await execAsync(restartCommand, {
+                cwd: deployPath,
+            });
+            utils_1.cliLogger.success(`Service ${serviceName} restarted successfully`);
+            utils_1.cliLogger.completeProcess(`Service ${serviceName} restarted successfully!`, {
+                Service: serviceName,
+                Profile: profileId,
+            });
+            this.logger.log(`Service ${serviceName} restarted successfully`);
+        }
+        catch (error) {
+            utils_1.cliLogger.error(`docker compose restart failed: ${error.message}`);
+            await this.markEventFailed(eventKey, `docker compose restart failed: ${error.message}`);
+        }
+    }
+    async downProfile(eventKey, profileId, workspaceId) {
+        utils_1.cliLogger.block({
+            title: 'Down profile (docker-compose down)',
+            context: 'ProfileService',
+            func: 'downProfile',
+            type: 'info',
+            metadata: {
+                profileId: profileId,
+                workspaceId: workspaceId || null,
+            },
+        });
+        if (!profileId) {
+            utils_1.cliLogger.block({
+                title: 'Profile ID is required',
+                context: 'ProfileService',
+                func: 'downProfile',
+                type: 'error',
+                metadata: {
+                    profileId: profileId,
+                    workspaceId: workspaceId || null,
+                },
+            });
+            return;
+        }
+        let deployPath = '/opt/docker-compose';
+        const profile = await this.getProfileDetails(profileId);
+        if (profile) {
+            deployPath =
+                profile.deploy_path || profile.deployPath || '/opt/docker-compose';
+        }
+        const composeFile = path.join(deployPath, `docker-compose_${profileId}.yaml`);
+        if (!fs.existsSync(composeFile)) {
+            utils_1.cliLogger.block({
+                title: 'Docker-compose file not found (downProfile)',
+                context: 'ProfileService',
+                func: 'downProfile',
+                type: 'error',
+                metadata: {
+                    profileId: profileId,
+                    composeFile: composeFile,
+                },
+            });
+            return;
+        }
+        utils_1.cliLogger.step(1, 2, 'Stopping log streams (downProfile)...');
+        await this.logService.stopLogStreamsForProfile(profileId);
+        utils_1.cliLogger.step(2, 2, 'Running docker-compose down...');
+        try {
+            const downCommand = wrapDockerCommand(`docker-compose -p "${profileId}" -f "${composeFile}" down`);
+            await execAsync(downCommand, {
+                cwd: deployPath,
+            });
+            utils_1.cliLogger.success('Docker-compose down completed');
+        }
+        catch (error) {
+            utils_1.cliLogger.error(`docker compose down failed: ${error.message}`);
+            await this.markEventFailed(eventKey, `docker compose down failed: ${error.message}`);
+            return;
+        }
+        const profileDir = path.join(this.configService.workDirPath, profileId);
+        const metadataFile = path.join(profileDir, '.profile_metadata');
+        await fs.remove(metadataFile).catch(() => { });
+        if (workspaceId && workspaceId !== 'null' && workspaceId !== 'undefined') {
+            await this.updateProfileStatus(profileId, workspaceId, false);
+        }
+        utils_1.cliLogger.block({
+            title: 'Profile down completed',
+            context: 'ProfileService',
+            func: 'downProfile',
+            type: 'success',
+            metadata: {
+                profileId: profileId,
+            },
+        });
+    }
+    async updateProfileStatus(profileId, workspaceId, isActive) {
+        const payload = {
+            workspace_id: workspaceId,
+            is_active: isActive,
+        };
+        await this.apiService.callApi('PUT', `/docker-profiles/${profileId}/status`, payload, -1, 10000);
+    }
+    async updateProfileServicesStatus(profileId, workspaceId) {
+        const servicesResponse = await this.apiService.callApi('GET', `/docker-profiles/${profileId}/services?workspace_id=${workspaceId}`, undefined, -1, 5000);
+        if (!servicesResponse) {
+            this.logger.error('[ERROR updateProfileServicesStatus] No services response from API');
+            return;
+        }
+        const services = servicesResponse.data?.rows || servicesResponse.rows || [];
+        if (!services || services.length === 0) {
+            this.logger.error('[ERROR updateProfileServicesStatus] No services found for profile');
+            return;
+        }
+        const profileDir = path.join(this.configService.workDirPath, profileId);
+        const servicesStatus = [];
+        for (const service of services) {
+            const serviceKey = service.key;
+            const serviceName = service.name;
+            if (!serviceKey || !serviceName) {
+                this.logger.error('[ERROR updateProfileServicesStatus] No service key or name found for service');
+                continue;
+            }
+            const status = await this.dockerService.getServiceStatus(serviceName, profileDir, profileId);
+            if (status && status !== 'unknown') {
+                servicesStatus.push({
+                    service_key: serviceKey,
+                    service_name: serviceName,
+                    status,
+                });
+            }
+        }
+        if (servicesStatus.length > 0) {
+            const payload = {
+                profile_key: profileId,
+                workspace_id: workspaceId,
+                services: servicesStatus,
+            };
+            await this.apiService.callApi('PUT', `/docker-profiles/${profileId}/services/status`, payload, -1, 5000);
+            const hasRunning = servicesStatus.some((s) => /^(running|up)/i.test(s.status));
+            await this.updateProfileStatus(profileId, workspaceId, hasRunning);
+        }
+        else {
+            const composeFile = path.join(profileDir, `docker-compose_${profileId}.yaml`);
+            if (fs.existsSync(composeFile)) {
+                const containers = await this.dockerService.getProfileContainers(profileId);
+                const runningContainers = containers.filter((c) => c.State === 'running' || (c.Status && /^Up/i.test(c.Status)));
+                const hasRunning = runningContainers.length > 0;
+                await this.updateProfileStatus(profileId, workspaceId, hasRunning);
+            }
+            else {
+                await this.updateProfileStatus(profileId, workspaceId, false);
+            }
+        }
+    }
+    async handlePrivateRegistries(profile) {
+        const services = profile.services || [];
+        const registries = new Map();
+        utils_1.cliLogger.block({
+            title: 'Detect private registries',
+            context: 'ProfileService',
+            func: 'handlePrivateRegistries',
+            type: 'debug',
+            metadata: {
+                servicesCount: Array.isArray(services) ? services.length : 0,
+            },
+        });
+        const sampleServices = Array.isArray(services) ? services.slice(0, 3) : [];
+        for (const s of sampleServices) {
+            const rawConfig = s?.config || {};
+            const cfg = rawConfig?.config || rawConfig;
+            utils_1.cliLogger.block({
+                title: 'Service config sample',
+                context: 'ProfileService',
+                func: 'handlePrivateRegistries',
+                type: 'debug',
+                metadata: {
+                    serviceName: s?.name,
+                    hasConfig: !!s?.config,
+                    rawConfigKeys: rawConfig ? Object.keys(rawConfig).slice(0, 20) : [],
+                    configKeys: cfg ? Object.keys(cfg).slice(0, 30) : [],
+                    isPrivate: cfg?.is_private_registry || cfg?.isPrivateRegistry,
+                    hasRegistryUrl: !!(cfg?.registry_url || cfg?.registryUrl),
+                    hasRegistryUsername: !!(cfg?.registry_username || cfg?.registryUsername),
+                    hasRegistryPassword: !!(cfg?.registry_password || cfg?.registryPassword),
+                },
+            });
+        }
+        for (const service of services) {
+            const rawConfig = service.config || {};
+            const config = rawConfig.config || rawConfig;
+            const isPrivate = config.is_private_registry || config.isPrivateRegistry;
+            utils_1.cliLogger.block({
+                title: 'Checking service for private registry',
+                context: 'ProfileService',
+                func: 'handlePrivateRegistries',
+                type: 'debug',
+                metadata: {
+                    serviceName: service?.name,
+                    hasConfig: !!service.config,
+                    isPrivate,
+                    registryUrl: config.registry_url || config.registryUrl,
+                    hasUsername: !!(config.registry_username || config.registryUsername),
+                    hasPassword: !!(config.registry_password || config.registryPassword),
+                },
+            });
+            if (isPrivate) {
+                const url = config.registry_url || config.registryUrl;
+                const username = config.registry_username || config.registryUsername;
+                const password = config.registry_password || config.registryPassword;
+                if (url && username && password) {
+                    if (!registries.has(url)) {
+                        registries.set(url, { url, username, password });
+                    }
+                }
+                else {
+                    utils_1.cliLogger.block({
+                        title: 'Skip private registry (missing credentials)',
+                        context: 'ProfileService',
+                        func: 'handlePrivateRegistries',
+                        type: 'warning',
+                        metadata: {
+                            serviceName: service?.name,
+                            hasUrl: !!url,
+                            hasUsername: !!username,
+                            hasPassword: !!password,
+                        },
+                    });
+                }
+            }
+        }
+        utils_1.cliLogger.block({
+            title: 'Private registries detected',
+            context: 'ProfileService',
+            func: 'handlePrivateRegistries',
+            type: 'debug',
+            metadata: {
+                registriesCount: registries.size,
+                registries: Array.from(registries.keys()),
+            },
+        });
+        if (registries.size > 0) {
+            utils_1.cliLogger.step(2, 5, `Logging into ${registries.size} private registry(ies)...`);
+        }
+        for (const registry of registries.values()) {
+            const success = await this.dockerService.dockerLogin(registry.url, registry.username, registry.password);
+            if (success) {
+                this.logger.log(`Docker login successful for registry: ${registry.url}`);
+                utils_1.cliLogger.success(`Docker login successful for registry: ${registry.url}`);
+            }
+            else {
+                const errorMsg = `Docker login failed for registry: ${registry.url}. Please check credentials.`;
+                this.logger.error(errorMsg);
+                utils_1.cliLogger.error(errorMsg);
+            }
+        }
+    }
+    async markEventRunning(eventKey) {
+        await this.apiService.callApi('PUT', `/events/${eventKey}`, {
+            status: 'running',
+        }, -1, 5000);
+    }
+    async markEventExecuted(eventKey) {
+        await this.apiService.callApi('PUT', `/events/${eventKey}`, {
+            status: 'executed',
+            is_executed: true,
+        }, -1, 5000);
+    }
+    async markEventFailed(eventKey, error) {
+        await this.apiService.callApi('PUT', `/events/${eventKey}`, {
+            status: 'failed',
+            is_executed: true,
+            error,
+        }, -1, 5000);
+    }
+    async handleContainerStateChanged(event) {
+        if (!this.useEventDrivenUpdates) {
+            utils_1.cliLogger.block({
+                title: 'Event-driven updates disabled, skipping Docker event',
+                context: 'ProfileService',
+                func: 'handleContainerStateChanged',
+                type: 'warning',
+                metadata: {
+                    event: event,
+                },
+            });
+            return;
+        }
+        utils_1.cliLogger.block({
+            title: 'Container state changed',
+            context: 'ProfileService',
+            func: 'handleContainerStateChanged',
+            type: 'info',
+            metadata: {
+                event: event,
+            },
+        });
+        const workspaceId = await this.getWorkspaceId(event.profileId);
+        if (!workspaceId) {
+            utils_1.cliLogger.block({
+                title: 'No workspace_id found for profile',
+                context: 'ProfileService',
+                func: 'handleContainerStateChanged',
+                type: 'warning',
+                metadata: {
+                    profileId: event.profileId,
+                },
+            });
+        }
+        const profileDir = path.join(this.configService.workDirPath, event.profileId);
+        const status = await this.dockerService.getServiceStatus(event.serviceName, profileDir, event.profileId);
+        utils_1.cliLogger.block({
+            title: 'Send Profile Status Update',
+            context: 'ProfileService',
+            func: 'handleContainerStateChanged',
+            type: 'info',
+            metadata: {
+                workspaceId: workspaceId,
+                profileId: event.profileId,
+                serviceName: event.serviceName,
+            },
+        });
+        await this.websocketClientService.sendStatusUpdate({
+            type: 'service_status',
+            workspace_id: workspaceId,
+            profile_key: event.profileId,
+            service_key: event.serviceName,
+            service_name: event.serviceName,
+            status: status,
+            container_id: event.containerId,
+            timestamp: Date.now(),
+        });
+        await this.updateProfileStatusFromDocker(event.profileId, workspaceId);
+    }
+    async getWorkspaceId(profileId) {
+        const profileDir = path.join(this.configService.workDirPath, profileId);
+        const metadataFile = path.join(profileDir, '.profile_metadata');
+        if (!fs.existsSync(metadataFile)) {
+            return null;
+        }
+        try {
+            const metadata = await fs.readFile(metadataFile, 'utf-8');
+            const workspaceIdMatch = metadata.match(/^workspace_id=(.+)$/m);
+            const workspaceId = workspaceIdMatch?.[1]?.trim();
+            if (!workspaceId ||
+                workspaceId === 'null' ||
+                workspaceId === 'undefined') {
+                return null;
+            }
+            return workspaceId;
+        }
+        catch (error) {
+            this.logger.error(`Error reading metadata for ${profileId}: ${error.message}`);
+            return null;
+        }
+    }
+    async updateProfileStatusFromDocker(profileId, workspaceId) {
+        const profileDir = path.join(this.configService.workDirPath, profileId);
+        const containers = await this.dockerService.getProfileContainers(profileId);
+        const runningContainers = containers.filter((c) => c.State === 'running' || (c.Status && /^Up/i.test(c.Status)));
+        const hasRunning = runningContainers.length > 0;
+        await this.websocketClientService.sendStatusUpdate({
+            type: 'profile_status',
+            workspace_id: workspaceId,
+            profile_key: profileId,
+            is_active: hasRunning,
+            timestamp: Date.now(),
+        });
+    }
+    async updateAllProfilesStatus() {
+        const machineKey = await this.configService.getMachineKey();
+        if (!machineKey) {
+            utils_1.cliLogger.block({
+                title: 'Machine key not found, cannot update profiles status',
+                context: 'ProfileService',
+                func: 'updateAllProfilesStatus',
+                type: 'warning',
+                metadata: {},
+            });
+            return;
+        }
+        utils_1.cliLogger.block({
+            title: `Starting updateAllProfilesStatus for machine_key: ${machineKey}`,
+            context: 'ProfileService',
+            func: 'updateAllProfilesStatus',
+            type: 'info',
+            metadata: {
+                machineKey: machineKey,
+            },
+        });
+        try {
+            const endpoint = `/docker-profiles?machine_key=${machineKey}`;
+            utils_1.cliLogger.block({
+                title: `Calling API: GET ${endpoint} (full URL will be: ${this.configService.apiBaseUrl}${endpoint})`,
+                context: 'ProfileService',
+                func: 'updateAllProfilesStatus',
+                type: 'debug',
+                metadata: {
+                    endpoint: endpoint,
+                },
+            });
+            const profilesResponse = await this.apiService.callApi('GET', endpoint, undefined, -1, 5000);
+            if (!profilesResponse) {
+                utils_1.cliLogger.block({
+                    title: `No profiles response from API for machine_key: ${machineKey}`,
+                    context: 'ProfileService',
+                    func: 'updateAllProfilesStatus',
+                    type: 'warning',
+                    metadata: {
+                        machineKey: machineKey,
+                    },
+                });
+                return;
+            }
+            utils_1.cliLogger.block({
+                title: `API response received: ${JSON.stringify(profilesResponse).substring(0, 500)}`,
+                context: 'ProfileService',
+                func: 'updateAllProfilesStatus',
+                type: 'debug',
+                metadata: {},
+            });
+            utils_1.cliLogger.debug(`API response structure: ${JSON.stringify({
+                hasData: !!profilesResponse.data,
+                hasRows: !!profilesResponse.rows,
+                dataKeys: profilesResponse.data
+                    ? Object.keys(profilesResponse.data)
+                    : [],
+                responseKeys: Object.keys(profilesResponse),
+                isArray: Array.isArray(profilesResponse),
+            })}`);
+            let profiles = profilesResponse.rows || [];
+            if (!profiles || profiles.length === 0) {
+                utils_1.cliLogger.block({
+                    title: `No profiles found for machine_key: ${machineKey}`,
+                    context: 'ProfileService',
+                    func: 'updateAllProfilesStatus',
+                    type: 'warning',
+                    metadata: {
+                        machineKey: machineKey,
+                    },
+                });
+                return;
+            }
+            utils_1.cliLogger.block({
+                title: `Found ${profiles.length} profile(s) for machine_key: ${machineKey}`,
+                context: 'ProfileService',
+                func: 'updateAllProfilesStatus',
+                type: 'debug',
+                metadata: {
+                    machineKey: machineKey,
+                    profiles: profiles.map((p) => p.key),
+                },
+            });
+            let updatedCount = 0;
+            for (const profile of profiles) {
+                try {
+                    const profileId = profile.key || profile.profile_key;
+                    const workspaceId = profile.workspace_id;
+                    const services = profile.services || [];
+                    if (!profileId || !workspaceId) {
+                        utils_1.cliLogger.block({
+                            title: 'Skipping profile - missing profileId or workspaceId',
+                            context: 'ProfileService',
+                            func: 'updateAllProfilesStatus',
+                            type: 'warning',
+                            metadata: {
+                                profileId: profileId,
+                                workspaceId: workspaceId,
+                            },
+                        });
+                        continue;
+                    }
+                    if (!services || services.length === 0) {
+                        utils_1.cliLogger.block({
+                            title: `Profile ${profileId} has no services, checking profile status only`,
+                            context: 'ProfileService',
+                            func: 'updateAllProfilesStatus',
+                            type: 'debug',
+                            metadata: {
+                                profileId: profileId,
+                            },
+                        });
+                        const containers = await this.dockerService.getProfileContainers(profileId);
+                        const runningContainers = containers.filter((c) => c.State === 'running' || (c.Status && /^Up/i.test(c.Status)));
+                        const hasRunning = runningContainers.length > 0;
+                        await this.updateProfileStatus(profileId, workspaceId, hasRunning);
+                        updatedCount++;
+                        continue;
+                    }
+                    const servicesStatus = [];
+                    for (const service of services) {
+                        const serviceKey = service.key;
+                        const serviceName = service.name;
+                        if (!serviceKey || !serviceName) {
+                            continue;
+                        }
+                        const containerNamePatterns = [
+                            `${serviceKey}_${serviceName}`,
+                            `${serviceKey}-${serviceName}`,
+                            `${serviceKey}${serviceName}`,
+                        ];
+                        let status = null;
+                        for (const containerName of containerNamePatterns) {
+                            status =
+                                await this.dockerService.getContainerStatus(containerName);
+                            if (status) {
+                                break;
+                            }
+                        }
+                        if (!status) {
+                            const profileDir = path.join(this.configService.workDirPath, profileId);
+                            status = await this.dockerService.getServiceStatus(serviceName, profileDir, profileId);
+                        }
+                        if (status && status !== 'unknown') {
+                            servicesStatus.push({
+                                service_key: serviceKey,
+                                service_name: serviceName,
+                                status,
+                            });
+                        }
+                    }
+                    if (servicesStatus.length > 0) {
+                        const payload = {
+                            profile_key: profileId,
+                            workspace_id: workspaceId,
+                            services: servicesStatus,
+                        };
+                        await this.apiService.callApi('PUT', `/docker-profiles/${profileId}/services/status`, payload, -1, 5000);
+                        const hasRunning = servicesStatus.some((s) => /^(running|up)/i.test(s.status));
+                        await this.updateProfileStatus(profileId, workspaceId, hasRunning);
+                    }
+                    else {
+                        const containers = await this.dockerService.getProfileContainers(profileId);
+                        const runningContainers = containers.filter((c) => c.State === 'running' || (c.Status && /^Up/i.test(c.Status)));
+                        const hasRunning = runningContainers.length > 0;
+                        await this.updateProfileStatus(profileId, workspaceId, hasRunning);
+                    }
+                    updatedCount++;
+                }
+                catch (error) {
+                    this.logger.error(`Error updating profile ${profile?.key || 'unknown'}: ${error.message}`);
+                }
+            }
+            if (updatedCount > 0) {
+                utils_1.cliLogger.block({
+                    title: `Updated status for ${updatedCount} profile(s)`,
+                    context: 'ProfileService',
+                    func: 'updateAllProfilesStatus',
+                    type: 'debug',
+                    metadata: {
+                        updatedCount: updatedCount,
+                    },
+                });
+            }
+        }
+        catch (error) {
+            utils_1.cliLogger.block({
+                title: `Error in updateAllProfilesStatus: ${error.message}`,
+                context: 'ProfileService',
+                func: 'updateAllProfilesStatus',
+                type: 'error',
+                metadata: {
+                    error: error.message,
+                },
+            });
+        }
+    }
+};
+exports.ProfileService = ProfileService;
+exports.ProfileService = ProfileService = ProfileService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [api_service_1.ApiService,
+        config_service_1.ConfigAgentService,
+        docker_service_1.DockerService,
+        docker_event_service_1.DockerEventService,
+        log_service_1.LogService,
+        websocket_client_service_1.WebSocketClientService])
+], ProfileService);
+//# sourceMappingURL=profile.service.js.map