@agentlang/agentmanager 0.0.3 → 0.0.4

package/dist/apps/monolith/apps/fabric/src/employees/employees.service.js

@@ -0,0 +1,952 @@
+"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 __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var EmployeesService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmployeesService = void 0;
+const common_1 = require("@nestjs/common");
+const node_path_1 = require("node:path");
+const configuration_1 = __importDefault(require("../config/configuration"));
+const runtime_store_1 = require("./runtime.store");
+const versions_service_1 = require("../versions/versions.service");
+const provider_interface_1 = require("../providers/provider.interface");
+const project_provider_1 = require("../../../../libs/project-provider/src");
+const provider_factory_1 = require("../providers/provider-factory");
+const port_allocator_1 = require("../providers/port-allocator");
+const environments_service_1 = require("../environments/environments.service");
+const project_source_service_1 = require("../project-source/project-source.service");
+const deployment_events_service_1 = require("../deployment-events/deployment-events.service");
+const logs_service_1 = require("../logs/logs.service");
+const notifications_service_1 = require("../notifications/notifications.service");
+const postgres_provisioner_service_1 = require("../provisioners/postgres-provisioner.service");
+const cognito_provisioner_service_1 = require("../provisioners/cognito-provisioner.service");
+const projects_data_service_1 = require("../projects/projects-data.service");
+const employee_deployment_errors_1 = require("./errors/employee-deployment.errors");
+const employees_types_1 = require("./employees.types");
+let EmployeesService = EmployeesService_1 = class EmployeesService {
+    runtimeStore;
+    versionsService;
+    provider;
+    providerFactory;
+    portAllocator;
+    environmentsService;
+    projectSource;
+    eventsService;
+    logsService;
+    notificationsService;
+    postgresProvisioner;
+    cognitoProvisioner;
+    config;
+    projectsDataService;
+    registry;
+    registryPath;
+    logger = new common_1.Logger(EmployeesService_1.name);
+    deploying = new Set();
+    constructor(runtimeStore, versionsService, provider, providerFactory, portAllocator, environmentsService, projectSource, eventsService, logsService, notificationsService, postgresProvisioner, cognitoProvisioner, config, projectsDataService, registry, registryPath) {
+        this.runtimeStore = runtimeStore;
+        this.versionsService = versionsService;
+        this.provider = provider;
+        this.providerFactory = providerFactory;
+        this.portAllocator = portAllocator;
+        this.environmentsService = environmentsService;
+        this.projectSource = projectSource;
+        this.eventsService = eventsService;
+        this.logsService = logsService;
+        this.notificationsService = notificationsService;
+        this.postgresProvisioner = postgresProvisioner;
+        this.cognitoProvisioner = cognitoProvisioner;
+        this.config = config;
+        this.projectsDataService = projectsDataService;
+        this.registry = registry;
+        this.registryPath = registryPath;
+    }
+    async onModuleDestroy() {
+        const entries = [...this.runtimeStore.listAll()];
+        const running = entries.filter((e) => e.entry.containerId &&
+            (e.entry.runtime === 'running' || e.entry.runtime === 'paused'));
+        if (running.length === 0)
+            return;
+        this.logger.log(`Graceful shutdown: stopping ${running.length} running process(es)`);
+        await Promise.allSettled(running.map(async (e) => {
+            try {
+                const resolved = this.resolveEnvironment(e.entry.environmentId ?? undefined);
+                if (e.entry.projectPath) {
+                    await this.logsService.saveStdoutLogsBeforeStop(e.entry.containerId, e.entry.projectPath, resolved.providerType);
+                }
+                await resolved.provider.stop(e.entry.containerId);
+                this.logger.log(`Stopped ${e.projectId}/${e.employeeId} (${e.env})`);
+            }
+            catch (err) {
+                this.logger.warn(`Failed to stop ${e.projectId}/${e.employeeId} (${e.env}): ${err}`);
+            }
+        }));
+    }
+    processName(projectId, employeeId, env) {
+        return `fabric-${projectId}-${employeeId}-${env}`;
+    }
+    resolveEnvironment(environmentId) {
+        if (!environmentId) {
+            return {
+                provider: this.provider,
+                providerType: this.config.provider,
+                envVars: {},
+                jsonConfig: {},
+                environmentId: null,
+            };
+        }
+        const env = this.environmentsService.get(environmentId);
+        return {
+            provider: this.providerFactory.get(env.providerType),
+            providerType: env.providerType,
+            envVars: env.envVars,
+            jsonConfig: env.jsonConfig,
+            environmentId: env.id,
+        };
+    }
+    async deploy(projectId, employeeId, env, environmentId, source, userId) {
+        const deployKey = `${projectId}/${employeeId}/${env}`;
+        if (this.deploying.has(deployKey)) {
+            throw new employee_deployment_errors_1.AlreadyInStateError(employeeId, env, 'deploying');
+        }
+        const now = new Date().toISOString();
+        let versionId;
+        if (env === 'live') {
+            const latest = this.versionsService.getLatest(projectId, employeeId);
+            if (!latest) {
+                throw new employee_deployment_errors_1.NoLiveVersionError(projectId, employeeId);
+            }
+            versionId = latest.versionId;
+        }
+        let projectPath;
+        let storedSource = source ?? null;
+        if (source) {
+            projectPath = await this.projectSource.resolve(source);
+        }
+        else {
+            const existing = this.runtimeStore.get(projectId, employeeId, env);
+            if (existing?.projectPath) {
+                projectPath = existing.projectPath;
+                storedSource = existing.source;
+            }
+            else {
+                const otherEnv = env === 'draft' ? 'live' : 'draft';
+                const other = this.runtimeStore.get(projectId, employeeId, otherEnv);
+                if (other?.projectPath) {
+                    projectPath = other.projectPath;
+                    storedSource = other.source;
+                }
+                else if (this.registry && this.registryPath) {
+                    try {
+                        await this.registry.getEmployee(projectId, employeeId);
+                        projectPath = (0, node_path_1.join)(this.registryPath, projectId, employeeId);
+                        storedSource = { type: 'local', path: projectPath };
+                    }
+                    catch {
+                        throw new employee_deployment_errors_1.EmployeeNotFoundError(projectId, employeeId);
+                    }
+                }
+                else {
+                    throw new employee_deployment_errors_1.EmployeeNotFoundError(projectId, employeeId);
+                }
+            }
+        }
+        let resolvedEnvironmentId = environmentId;
+        if (!resolvedEnvironmentId) {
+            const project = await this.projectsDataService.get(projectId);
+            if (project) {
+                resolvedEnvironmentId = project.environmentId;
+            }
+        }
+        const resolved = this.resolveEnvironment(resolvedEnvironmentId);
+        const port = await this.portAllocator.allocateVerified();
+        const resolvedUserId = userId ?? null;
+        this.runtimeStore.set(projectId, employeeId, env, {
+            userId: resolvedUserId,
+            runtime: 'pending',
+            deployedAt: now,
+            lastError: null,
+            versionId: versionId ?? null,
+            publishedAt: versionId ? now : null,
+            moduleCount: 0,
+            containerId: null,
+            port,
+            environmentId: resolved.environmentId,
+            projectPath,
+            source: storedSource,
+            healthcheckRetryCount: 0,
+            envVars: null,
+        });
+        this.runDeploy(projectId, employeeId, env, projectPath, port, versionId, storedSource, resolved, resolvedUserId).catch((err) => {
+            this.logger.error(`Unexpected error in runDeploy for ${deployKey}: ${err}`);
+        });
+        return {
+            projectId,
+            employeeId,
+            env,
+            runtime: 'pending',
+            deployedAt: now,
+            versionId,
+            port,
+            environmentId: resolved.environmentId ?? undefined,
+        };
+    }
+    async runDeploy(projectId, employeeId, env, projectPath, port, versionId, storedSource, resolved, userId) {
+        const deployKey = `${projectId}/${employeeId}/${env}`;
+        this.deploying.add(deployKey);
+        const now = new Date().toISOString();
+        const name = this.processName(projectId, employeeId, env);
+        try {
+            this.runtimeStore.updateField(projectId, employeeId, env, {
+                runtime: 'cloning',
+            });
+            this.runtimeStore.updateField(projectId, employeeId, env, {
+                runtime: 'building',
+            });
+            const baseAppConfig = { service: { port } };
+            let mergedConfig = {
+                ...resolved.jsonConfig,
+                ...baseAppConfig,
+            };
+            const envVars = {
+                ...resolved.envVars,
+                PORT: String(port),
+            };
+            const storeConfig = mergedConfig.store;
+            if (storeConfig?.type === 'postgres') {
+                try {
+                    let creds;
+                    try {
+                        const project = await this.projectsDataService.get(projectId);
+                        if (project?.dbName) {
+                            creds = this.postgresProvisioner.getCredentialsForExistingDb(project.dbName);
+                        }
+                    }
+                    catch {
+                    }
+                    if (!creds) {
+                        creds = await this.postgresProvisioner.createDatabase(`${projectId}_${employeeId}_${env}`);
+                    }
+                    mergedConfig = {
+                        ...mergedConfig,
+                        store: {
+                            ...storeConfig,
+                            type: 'postgres',
+                            dbname: creds.dbname,
+                            host: creds.host,
+                            port: creds.port,
+                            username: creds.username,
+                            password: creds.password,
+                        },
+                    };
+                }
+                catch (err) {
+                    this.logger.warn(`Postgres provisioning failed: ${err}`);
+                }
+            }
+            const authConfig = mergedConfig.auth;
+            if (authConfig?.enabled === true) {
+                try {
+                    const cognito = await this.cognitoProvisioner.provision(`${projectId}-${employeeId}-${env}`, '', '');
+                    envVars.COGNITO_USER_POOL_ID = cognito.userPoolId;
+                    envVars.COGNITO_CLIENT_ID = cognito.clientId;
+                    envVars.AWS_REGION = cognito.region;
+                    envVars.COGNITO_DEFAULT_USER_PASSWORD = cognito.defaultPassword;
+                    const awsKey = this.config.aws.accessKeyId;
+                    const awsSecret = this.config.aws.secretAccessKey;
+                    if (awsKey)
+                        envVars.AWS_ACCESS_KEY_ID = awsKey;
+                    if (awsSecret)
+                        envVars.AWS_SECRET_ACCESS_KEY = awsSecret;
+                }
+                catch (err) {
+                    this.logger.warn(`Cognito provisioning failed: ${err}`);
+                }
+            }
+            envVars.APP_CONFIG = JSON.stringify(mergedConfig);
+            this.runtimeStore.updateField(projectId, employeeId, env, {
+                runtime: 'deploying',
+                envVars,
+            });
+            const result = await resolved.provider.deploy(name, projectPath, envVars, port, { projectId, employeeId });
+            if (!result.success) {
+                const errMsg = result.error ?? 'Deploy failed';
+                this.runtimeStore.set(projectId, employeeId, env, {
+                    userId,
+                    runtime: 'failed',
+                    deployedAt: now,
+                    lastError: errMsg,
+                    versionId: versionId ?? null,
+                    publishedAt: versionId ? now : null,
+                    moduleCount: 0,
+                    containerId: null,
+                    port: null,
+                    environmentId: resolved.environmentId,
+                    projectPath,
+                    source: storedSource,
+                    healthcheckRetryCount: 0,
+                    envVars,
+                });
+                this.logger.error(`Failed to deploy ${projectId}/${employeeId} (${env}): ${errMsg}`);
+                this.eventsService.create({
+                    userId,
+                    projectId,
+                    employeeId,
+                    env,
+                    type: 'error',
+                    message: errMsg,
+                });
+                this.notificationsService
+                    .notifyOnFailure(userId ?? '__anonymous__', {
+                    projectId,
+                    employeeId,
+                    env,
+                    type: 'error',
+                    message: errMsg,
+                })
+                    .catch((notifyErr) => {
+                    this.logger.warn(`Failed to send failure notification: ${notifyErr}`);
+                });
+                return;
+            }
+            this.runtimeStore.set(projectId, employeeId, env, {
+                userId,
+                runtime: 'running',
+                deployedAt: now,
+                lastError: null,
+                versionId: versionId ?? null,
+                publishedAt: versionId ? now : null,
+                moduleCount: 0,
+                containerId: result.containerId ?? null,
+                port,
+                environmentId: resolved.environmentId,
+                projectPath,
+                source: storedSource,
+                healthcheckRetryCount: 0,
+                envVars,
+            });
+            this.logger.log(`Deployed ${projectId}/${employeeId} (${env}) → ${result.containerId} on port ${port}`);
+            this.eventsService.create({
+                userId,
+                projectId,
+                employeeId,
+                env,
+                type: 'start',
+                message: 'Deployment started successfully',
+            });
+        }
+        catch (err) {
+            const errMsg = err instanceof Error ? err.message : String(err);
+            this.runtimeStore.updateField(projectId, employeeId, env, {
+                runtime: 'failed',
+                lastError: errMsg,
+            });
+            this.eventsService.create({
+                userId,
+                projectId,
+                employeeId,
+                env,
+                type: 'error',
+                message: errMsg,
+            });
+            this.notificationsService
+                .notifyOnFailure(userId ?? '__anonymous__', {
+                projectId,
+                employeeId,
+                env,
+                type: 'error',
+                message: errMsg,
+            })
+                .catch((notifyErr) => {
+                this.logger.warn(`Failed to send failure notification: ${notifyErr}`);
+            });
+        }
+        finally {
+            this.deploying.delete(deployKey);
+        }
+    }
+    async stop(projectId, employeeId, env) {
+        const existing = this.runtimeStore.get(projectId, employeeId, env);
+        if (existing?.runtime === 'stopped') {
+            throw new employee_deployment_errors_1.AlreadyInStateError(employeeId, env, 'stopped');
+        }
+        if (existing?.containerId) {
+            const resolved = this.resolveEnvironment(existing.environmentId ?? undefined);
+            if (existing.projectPath) {
+                await this.logsService.saveStdoutLogsBeforeStop(existing.containerId, existing.projectPath, resolved.providerType);
+            }
+            await resolved.provider.stop(existing.containerId);
+            if (existing.envVars?.COGNITO_USER_POOL_ID) {
+                try {
+                    await this.cognitoProvisioner.deletePool(existing.envVars.COGNITO_USER_POOL_ID);
+                }
+                catch (err) {
+                    this.logger.error(`Failed to delete Cognito pool: ${err}`);
+                }
+            }
+            const appConfigStr = existing.envVars?.APP_CONFIG;
+            if (appConfigStr) {
+                try {
+                    const appConfig = JSON.parse(appConfigStr);
+                    const storeConfig = appConfig.store;
+                    const dbname = storeConfig?.dbname;
+                    if (storeConfig?.type === 'postgres' && dbname) {
+                        let isSharedDb = false;
+                        try {
+                            const project = await this.projectsDataService.get(projectId);
+                            isSharedDb = project?.dbName === dbname;
+                        }
+                        catch {
+                        }
+                        if (!isSharedDb) {
+                            await this.postgresProvisioner.dropDatabase(dbname);
+                        }
+                    }
+                }
+                catch (err) {
+                    this.logger.error(`Failed to drop database: ${err}`);
+                }
+            }
+        }
+        this.runtimeStore.set(projectId, employeeId, env, {
+            userId: existing?.userId ?? null,
+            runtime: 'stopped',
+            deployedAt: existing?.deployedAt ?? null,
+            lastError: null,
+            versionId: existing?.versionId ?? null,
+            publishedAt: existing?.publishedAt ?? null,
+            moduleCount: existing?.moduleCount ?? 0,
+            containerId: null,
+            port: null,
+            environmentId: existing?.environmentId ?? null,
+            projectPath: existing?.projectPath ?? null,
+            source: existing?.source ?? null,
+            healthcheckRetryCount: 0,
+            envVars: existing?.envVars ?? null,
+        });
+        this.logger.log(`Stopped ${projectId}/${employeeId} (${env})`);
+        this.eventsService.create({
+            userId: existing?.userId,
+            projectId,
+            employeeId,
+            env,
+            type: 'stop',
+            message: 'Deployment stopped',
+        });
+        return {
+            projectId,
+            employeeId,
+            env,
+            runtime: 'stopped',
+            deployedAt: existing?.deployedAt ?? new Date().toISOString(),
+        };
+    }
+    async pause(projectId, employeeId, env) {
+        const existing = this.runtimeStore.get(projectId, employeeId, env);
+        if (!existing || existing.runtime !== 'running') {
+            throw new employee_deployment_errors_1.InvalidStateTransitionError(employeeId, env, existing?.runtime ?? 'unknown', 'paused');
+        }
+        if (existing.containerId) {
+            const resolved = this.resolveEnvironment(existing.environmentId ?? undefined);
+            if (existing.projectPath) {
+                await this.logsService.saveStdoutLogsBeforeStop(existing.containerId, existing.projectPath, resolved.providerType);
+            }
+            await resolved.provider.stop(existing.containerId);
+        }
+        this.runtimeStore.set(projectId, employeeId, env, {
+            ...existing,
+            runtime: 'paused',
+            lastError: null,
+            containerId: null,
+        });
+        this.logger.log(`Paused ${projectId}/${employeeId} (${env})`);
+        this.eventsService.create({
+            userId: existing.userId,
+            projectId,
+            employeeId,
+            env,
+            type: 'stop',
+            message: 'Deployment paused',
+        });
+        return {
+            projectId,
+            employeeId,
+            env,
+            runtime: 'paused',
+            deployedAt: existing.deployedAt ?? new Date().toISOString(),
+            versionId: existing.versionId ?? undefined,
+            containerId: existing.containerId ?? undefined,
+            port: existing.port ?? undefined,
+        };
+    }
+    async resume(projectId, employeeId, env) {
+        const existing = this.runtimeStore.get(projectId, employeeId, env);
+        if (!existing ||
+            (existing.runtime !== 'paused' && existing.runtime !== 'stopped')) {
+            throw new employee_deployment_errors_1.InvalidStateTransitionError(employeeId, env, existing?.runtime ?? 'unknown', 'running');
+        }
+        if (existing.runtime === 'stopped') {
+            return this.deploy(projectId, employeeId, env, existing.environmentId ?? undefined);
+        }
+        const resolved = this.resolveEnvironment(existing.environmentId ?? undefined);
+        const name = this.processName(projectId, employeeId, env);
+        const projectPath = existing.projectPath;
+        const port = existing.port ?? this.portAllocator.allocate();
+        const now = new Date().toISOString();
+        const envVars = existing.envVars ?? resolved.envVars;
+        const result = await resolved.provider.deploy(name, projectPath, envVars, port, { projectId, employeeId });
+        if (!result.success) {
+            this.runtimeStore.set(projectId, employeeId, env, {
+                ...existing,
+                runtime: 'crashed',
+                lastError: result.error ?? 'Resume failed',
+            });
+            this.logger.error(`Failed to resume ${projectId}/${employeeId} (${env}): ${result.error}`);
+            this.eventsService.create({
+                userId: existing.userId,
+                projectId,
+                employeeId,
+                env,
+                type: 'error',
+                message: result.error ?? 'Resume failed',
+            });
+            return {
+                projectId,
+                employeeId,
+                env,
+                runtime: 'crashed',
+                deployedAt: existing.deployedAt ?? now,
+                versionId: existing.versionId ?? undefined,
+            };
+        }
+        this.runtimeStore.set(projectId, employeeId, env, {
+            ...existing,
+            runtime: 'running',
+            deployedAt: now,
+            lastError: null,
+            containerId: result.containerId ?? existing.containerId,
+            port,
+        });
+        this.logger.log(`Resumed ${projectId}/${employeeId} (${env})`);
+        this.eventsService.create({
+            userId: existing.userId,
+            projectId,
+            employeeId,
+            env,
+            type: 'start',
+            message: 'Deployment resumed',
+        });
+        return {
+            projectId,
+            employeeId,
+            env,
+            runtime: 'running',
+            deployedAt: now,
+            versionId: existing.versionId ?? undefined,
+            containerId: result.containerId ?? existing.containerId ?? undefined,
+            port,
+            environmentId: existing.environmentId ?? undefined,
+        };
+    }
+    async restart(projectId, employeeId, env) {
+        const existing = this.runtimeStore.get(projectId, employeeId, env);
+        if (!existing?.containerId) {
+            throw new employee_deployment_errors_1.EmployeeNotFoundError(projectId, employeeId);
+        }
+        const resolved = this.resolveEnvironment(existing.environmentId ?? undefined);
+        await resolved.provider.restart(existing.containerId);
+        const now = new Date().toISOString();
+        this.runtimeStore.set(projectId, employeeId, env, {
+            ...existing,
+            runtime: 'running',
+            deployedAt: now,
+            lastError: null,
+        });
+        this.logger.log(`Restarted ${projectId}/${employeeId} (${env})`);
+        this.eventsService.create({
+            userId: existing.userId,
+            projectId,
+            employeeId,
+            env,
+            type: 'restart',
+            message: 'Deployment restarted',
+        });
+        return {
+            projectId,
+            employeeId,
+            env,
+            runtime: 'running',
+            deployedAt: now,
+            versionId: existing.versionId ?? undefined,
+            containerId: existing.containerId,
+            port: existing.port ?? undefined,
+        };
+    }
+    async publish(projectId, employeeId) {
+        const version = this.versionsService.create(projectId, employeeId);
+        this.logger.log(`Published ${projectId}/${employeeId} as ${version.versionId}`);
+        const existing = this.runtimeStore.get(projectId, employeeId, 'live');
+        return this.deploy(projectId, employeeId, 'live', existing?.environmentId ?? undefined);
+    }
+    async unpublish(projectId, employeeId) {
+        const result = await this.stop(projectId, employeeId, 'live');
+        this.runtimeStore.delete(projectId, employeeId, 'live');
+        this.logger.log(`Unpublished ${projectId}/${employeeId}`);
+        return result;
+    }
+    async rollback(projectId, employeeId, versionId) {
+        const version = versionId
+            ? this.versionsService.get(projectId, employeeId, versionId)
+            : this.versionsService.getPrevious(projectId, employeeId);
+        if (!version) {
+            throw new employee_deployment_errors_1.NoLiveVersionError(projectId, employeeId);
+        }
+        const existing = this.runtimeStore.get(projectId, employeeId, 'live');
+        if (existing?.containerId) {
+            try {
+                const resolved = this.resolveEnvironment(existing.environmentId ?? undefined);
+                await resolved.provider.stop(existing.containerId);
+            }
+            catch (err) {
+                this.logger.warn(`Best-effort stop before rollback failed for ${projectId}/${employeeId}: ${err instanceof Error ? err.message : err}`);
+            }
+        }
+        return this.deploy(projectId, employeeId, 'live', existing?.environmentId ?? undefined);
+    }
+    getStatus(projectId, employeeId) {
+        const draft = this.runtimeStore.get(projectId, employeeId, 'draft');
+        const live = this.runtimeStore.get(projectId, employeeId, 'live');
+        return {
+            projectId,
+            employeeId,
+            draft: this.runtimeStore.toDraftInfo(draft),
+            live: this.runtimeStore.toLiveInfo(live),
+            draftAheadOfLive: !!draft?.deployedAt &&
+                (!live?.deployedAt || draft.deployedAt > live.deployedAt),
+        };
+    }
+    getBulkStatus(projectId) {
+        const entries = this.runtimeStore.listByProject(projectId);
+        const employeeIds = [...new Set(entries.map((e) => e.employeeId))];
+        return employeeIds.map((id) => this.getStatus(projectId, id));
+    }
+    resolve(projectId, employeeId, env) {
+        const entry = this.runtimeStore.get(projectId, employeeId, env);
+        return {
+            projectId,
+            employeeId,
+            env,
+            runtime: entry?.runtime ?? 'stopped',
+            endpoint: entry?.runtime === 'running' && entry.port
+                ? `http://localhost:${entry.port}`
+                : null,
+            port: entry?.port ?? null,
+            containerId: entry?.containerId ?? null,
+            capabilities: [],
+        };
+    }
+    async recoverIfProcessMissing(projectId, employeeId, env) {
+        const existing = this.runtimeStore.get(projectId, employeeId, env);
+        if (!existing || existing.runtime !== 'running' || !existing.containerId) {
+            return;
+        }
+        const deployKey = `${projectId}/${employeeId}/${env}`;
+        if (this.deploying.has(deployKey)) {
+            return;
+        }
+        const resolved = this.resolveEnvironment(existing.environmentId ?? undefined);
+        const provider = resolved.provider;
+        let status;
+        try {
+            status = await provider.getStatus(existing.containerId);
+        }
+        catch (err) {
+            this.logger.warn(`Deployment watcher: getStatus failed for ${projectId}/${employeeId} (${env}): ${err instanceof Error ? err.message : err}`);
+            return;
+        }
+        if (status === 'running') {
+            return;
+        }
+        this.logger.warn(`Deployment watcher: ${projectId}/${employeeId} (${env}) provider status is "${status}" but Fabric state is running — recovering`);
+        if (status === 'stopped') {
+            try {
+                await provider.restart(existing.containerId);
+                const after = await provider.getStatus(existing.containerId);
+                if (after === 'running') {
+                    this.eventsService.create({
+                        userId: existing.userId,
+                        projectId,
+                        employeeId,
+                        env,
+                        type: 'watcher_recover',
+                        message: 'Process was stopped externally; provider restart succeeded.',
+                    });
+                    return;
+                }
+            }
+            catch (err) {
+                this.logger.warn(`Deployment watcher: restart failed for ${projectId}/${employeeId} (${env}): ${err instanceof Error ? err.message : err}`);
+            }
+        }
+        try {
+            await this.deploy(projectId, employeeId, env, existing.environmentId ?? undefined, undefined, existing.userId);
+            this.eventsService.create({
+                userId: existing.userId,
+                projectId,
+                employeeId,
+                env,
+                type: 'watcher_recover',
+                message: status === 'not_found'
+                    ? 'Process no longer present in provider; redeploy started.'
+                    : 'Restart failed or process still down; redeploy started.',
+            });
+        }
+        catch (err) {
+            if (err instanceof employee_deployment_errors_1.AlreadyInStateError) {
+                return;
+            }
+            this.logger.error(`Deployment watcher: redeploy failed for ${projectId}/${employeeId} (${env}): ${err instanceof Error ? err.message : err}`);
+        }
+    }
+    async getLogs(projectId, employeeId, env, options) {
+        const entry = this.runtimeStore.get(projectId, employeeId, env);
+        const providerType = entry?.environmentId
+            ? this.resolveEnvironment(entry.environmentId).providerType
+            : null;
+        return this.logsService.getDeploymentLogs(entry?.containerId ?? null, entry?.projectPath ?? null, providerType, {
+            type: options?.type ?? 'stdout',
+            date: options?.date,
+            tail: options?.tail,
+        });
+    }
+    async undeploy(projectId, employeeId, track, fabricEnvironmentId) {
+        const existing = this.runtimeStore.get(projectId, employeeId, track);
+        if (!existing) {
+            throw new employee_deployment_errors_1.EmployeeNotFoundError(projectId, employeeId);
+        }
+        const project = await this.projectsDataService.get(projectId);
+        const expectedEnvId = existing.environmentId ?? project?.environmentId ?? null;
+        const resolvedFabricEnvId = fabricEnvironmentId ?? (expectedEnvId || undefined);
+        if (!resolvedFabricEnvId) {
+            throw new employee_deployment_errors_1.UndeployEnvironmentUnresolvedError(projectId, employeeId, track);
+        }
+        if (expectedEnvId && resolvedFabricEnvId !== expectedEnvId) {
+            throw new employee_deployment_errors_1.DeploymentEnvironmentMismatchError(projectId, employeeId, track, expectedEnvId, resolvedFabricEnvId);
+        }
+        if (!expectedEnvId) {
+            this.environmentsService.get(resolvedFabricEnvId);
+        }
+        if (employees_types_1.ACTIVE_DEPLOYMENT_STATUSES.includes(existing.runtime)) {
+            await this.stop(projectId, employeeId, track);
+        }
+        const { removed } = await this.remove(projectId, employeeId, track);
+        return { removed, projectId, employeeId, env: track };
+    }
+    async remove(projectId, employeeId, env) {
+        const existing = this.runtimeStore.get(projectId, employeeId, env);
+        if (!existing) {
+            throw new employee_deployment_errors_1.EmployeeNotFoundError(projectId, employeeId);
+        }
+        if (existing.runtime !== 'stopped' &&
+            existing.runtime !== 'failed' &&
+            existing.runtime !== 'crashed') {
+            throw new employee_deployment_errors_1.CannotRemoveError(employeeId, env, existing.runtime);
+        }
+        this.runtimeStore.delete(projectId, employeeId, env);
+        this.logger.log(`Removed ${projectId}/${employeeId} (${env})`);
+        this.eventsService.create({
+            userId: existing.userId,
+            projectId,
+            employeeId,
+            env,
+            type: 'remove',
+            message: 'Deployment removed',
+        });
+        await Promise.resolve();
+        return { removed: true };
+    }
+    async reconfigureDbAndRedeploy(projectId, employeeId, env) {
+        const existing = this.runtimeStore.get(projectId, employeeId, env);
+        if (!existing?.projectPath || !existing.envVars)
+            return null;
+        const appConfigStr = existing.envVars.APP_CONFIG ?? '{}';
+        let appConfig;
+        try {
+            appConfig = JSON.parse(appConfigStr);
+        }
+        catch {
+            return null;
+        }
+        const storeConfig = appConfig.store;
+        if (storeConfig?.type !== 'postgres')
+            return null;
+        const resolved = this.resolveEnvironment(existing.environmentId ?? undefined);
+        const name = this.processName(projectId, employeeId, env);
+        try {
+            const creds = await this.postgresProvisioner.createNewDatabase(`${projectId}_${employeeId}_${env}`);
+            const newStoreConfig = {
+                ...storeConfig,
+                dbname: creds.dbname,
+                host: creds.host,
+                port: creds.port,
+                username: creds.username,
+                password: creds.password,
+            };
+            const newAppConfig = { ...appConfig, store: newStoreConfig };
+            const newEnvVars = {
+                ...existing.envVars,
+                APP_CONFIG: JSON.stringify(newAppConfig),
+            };
+            if (existing.containerId) {
+                if (existing.projectPath) {
+                    await this.logsService.saveStdoutLogsBeforeStop(existing.containerId, existing.projectPath, resolved.providerType);
+                }
+                await resolved.provider.stop(existing.containerId);
+            }
+            const now = new Date().toISOString();
+            this.runtimeStore.set(projectId, employeeId, env, {
+                ...existing,
+                envVars: newEnvVars,
+                containerId: null,
+                runtime: 'deploying',
+                lastError: null,
+                healthcheckRetryCount: 0,
+            });
+            const result = await resolved.provider.deploy(name, existing.projectPath, newEnvVars, existing.port, { projectId, employeeId });
+            if (!result.success) {
+                this.runtimeStore.updateField(projectId, employeeId, env, {
+                    runtime: 'failed',
+                    lastError: result.error ?? 'Reconfigure deploy failed',
+                });
+                this.eventsService.create({
+                    userId: existing.userId,
+                    projectId,
+                    employeeId,
+                    env,
+                    type: 'error',
+                    message: result.error ?? 'Reconfigure deploy failed',
+                });
+                return {
+                    projectId,
+                    employeeId,
+                    env,
+                    runtime: 'failed',
+                    deployedAt: existing.deployedAt ?? now,
+                };
+            }
+            this.runtimeStore.set(projectId, employeeId, env, {
+                ...existing,
+                runtime: 'running',
+                containerId: result.containerId ?? null,
+                envVars: newEnvVars,
+                lastError: null,
+                healthcheckRetryCount: 0,
+            });
+            this.eventsService.create({
+                userId: existing.userId,
+                projectId,
+                employeeId,
+                env,
+                type: 'restart',
+                message: 'Database reconfigured and deployment redeployed',
+            });
+            this.logger.log(`Reconfigured DB and redeployed ${projectId}/${employeeId} (${env})`);
+            return {
+                projectId,
+                employeeId,
+                env,
+                runtime: 'running',
+                deployedAt: now,
+                containerId: result.containerId ?? undefined,
+                port: existing.port ?? undefined,
+            };
+        }
+        catch (err) {
+            const errMsg = err instanceof Error ? err.message : String(err);
+            this.runtimeStore.updateField(projectId, employeeId, env, {
+                runtime: 'failed',
+                lastError: errMsg,
+            });
+            this.eventsService.create({
+                userId: existing.userId,
+                projectId,
+                employeeId,
+                env,
+                type: 'error',
+                message: errMsg,
+            });
+            return null;
+        }
+    }
+    async checkHealth(projectId, employeeId, env) {
+        const entry = this.runtimeStore.get(projectId, employeeId, env);
+        if (!entry?.port || entry.runtime !== 'running') {
+            return { ok: false, error: 'Deployment not running' };
+        }
+        const url = `http://localhost:${entry.port}/health`;
+        try {
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), 5000);
+            const res = await fetch(url, {
+                method: 'GET',
+                signal: controller.signal,
+            });
+            clearTimeout(timeout);
+            let healthData;
+            try {
+                const text = await res.text();
+                healthData = text
+                    ? JSON.parse(text)
+                    : undefined;
+            }
+            catch {
+            }
+            if (res.ok) {
+                return { ok: true, status: res.status, healthData };
+            }
+            return {
+                ok: false,
+                status: res.status,
+                error: `HTTP ${res.status}`,
+                healthData,
+            };
+        }
+        catch (err) {
+            const error = err instanceof Error ? err.message : String(err);
+            return { ok: false, error };
+        }
+    }
+};
+exports.EmployeesService = EmployeesService;
+exports.EmployeesService = EmployeesService = EmployeesService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(2, (0, common_1.Inject)(provider_interface_1.DEPLOYMENT_PROVIDER)),
+    __param(12, (0, common_1.Inject)(configuration_1.default.KEY)),
+    __param(14, (0, common_1.Optional)()),
+    __param(14, (0, common_1.Inject)(project_provider_1.REGISTRY_PROVIDER)),
+    __param(15, (0, common_1.Optional)()),
+    __param(15, (0, common_1.Inject)(project_provider_1.REGISTRY_PATH)),
+    __metadata("design:paramtypes", [runtime_store_1.RuntimeStore,
+        versions_service_1.VersionsService, Object, provider_factory_1.ProviderFactory,
+        port_allocator_1.PortAllocator,
+        environments_service_1.EnvironmentsService,
+        project_source_service_1.ProjectSourceService,
+        deployment_events_service_1.DeploymentEventsService,
+        logs_service_1.LogsService,
+        notifications_service_1.NotificationsService,
+        postgres_provisioner_service_1.PostgresProvisionerService,
+        cognito_provisioner_service_1.CognitoProvisionerService, void 0, projects_data_service_1.ProjectsDataService, Object, Object])
+], EmployeesService);
+//# sourceMappingURL=employees.service.js.map