@agentlang/agentmanager 0.0.3

package/apps/fabric/src/environments/environments.store.ts

@@ -0,0 +1,146 @@
+import {
+  Injectable,
+  OnModuleInit,
+  OnModuleDestroy,
+  Logger,
+} from '@nestjs/common';
+import type { Repository } from 'typeorm';
+import { FileStoreFactory, FileStore, DataSourceService } from '@app/common';
+import { EnvironmentEntity } from '../database/entities';
+import type { Environment } from './environments.types';
+
+interface PersistedData {
+  counter: number;
+  environments: Record<string, Environment>;
+}
+
+@Injectable()
+export class EnvironmentsStore implements OnModuleInit, OnModuleDestroy {
+  private readonly logger = new Logger(EnvironmentsStore.name);
+  private counter = 0;
+  private readonly environments = new Map<string, Environment>();
+  private readonly fileStore: FileStore<PersistedData>;
+  private repo: Repository<EnvironmentEntity> | null = null;
+
+  constructor(
+    fileStoreFactory: FileStoreFactory,
+    private readonly dataSourceService: DataSourceService,
+  ) {
+    this.fileStore =
+      fileStoreFactory.create<PersistedData>('environments.json');
+  }
+
+  async onModuleInit() {
+    this.repo = this.dataSourceService.getRepository(EnvironmentEntity);
+
+    if (this.repo) {
+      const rows = await this.repo.find();
+      for (const row of rows) {
+        this.environments.set(row.id, this.entityToEnvironment(row));
+      }
+      for (const id of this.environments.keys()) {
+        const match = id.match(/^env-(\d+)$/);
+        if (match) {
+          this.counter = Math.max(this.counter, parseInt(match[1], 10));
+        }
+      }
+      this.logger.log(
+        `Loaded ${this.environments.size} environments (counter=${this.counter}) from database`,
+      );
+    } else {
+      const data = await this.fileStore.load();
+      if (data) {
+        this.counter = data.counter ?? 0;
+        if (data.environments) {
+          for (const [key, env] of Object.entries(data.environments)) {
+            this.environments.set(key, env);
+          }
+        }
+        this.logger.log(
+          `Loaded ${this.environments.size} environments (counter=${this.counter}) from disk`,
+        );
+      }
+    }
+  }
+
+  private entityToEnvironment(entity: EnvironmentEntity): Environment {
+    return {
+      id: entity.id,
+      name: entity.name,
+      providerType: entity.providerType as Environment['providerType'],
+      envVars: entity.envVars,
+      jsonConfig: entity.jsonConfig,
+      createdAt: entity.createdAt,
+      updatedAt: entity.updatedAt,
+    };
+  }
+
+  private environmentToEntity(env: Environment): EnvironmentEntity {
+    const entity = new EnvironmentEntity();
+    entity.id = env.id;
+    entity.name = env.name;
+    entity.providerType = env.providerType;
+    entity.envVars = env.envVars;
+    entity.jsonConfig = env.jsonConfig;
+    entity.createdAt = env.createdAt;
+    entity.updatedAt = env.updatedAt;
+    return entity;
+  }
+
+  private persist(env?: Environment): void {
+    if (this.repo && env) {
+      this.repo
+        .save(this.environmentToEntity(env))
+        .catch((err) =>
+          this.logger.error(`Failed to persist environment: ${err}`),
+        );
+    } else if (!this.repo) {
+      const environments: Record<string, Environment> = {};
+      for (const [key, e] of this.environments) {
+        environments[key] = e;
+      }
+      this.fileStore.save({ counter: this.counter, environments });
+    }
+  }
+
+  generateId(): string {
+    return `env-${++this.counter}`;
+  }
+
+  get(id: string): Environment | undefined {
+    return this.environments.get(id);
+  }
+
+  set(env: Environment): void {
+    this.environments.set(env.id, env);
+    this.persist(env);
+  }
+
+  delete(id: string): boolean {
+    const result = this.environments.delete(id);
+    if (result && this.repo) {
+      this.repo
+        .delete({ id })
+        .catch((err) =>
+          this.logger.error(`Failed to delete environment: ${err}`),
+        );
+    }
+    if (!this.repo) {
+      this.persist();
+    }
+    return result;
+  }
+
+  list(): Environment[] {
+    return [...this.environments.values()];
+  }
+
+  async onModuleDestroy() {
+    if (!this.repo) {
+      await this.fileStore.flush();
+    }
+    this.logger.log(
+      `EnvironmentsStore shutting down with ${this.environments.size} environments`,
+    );
+  }
+}

package/apps/fabric/src/environments/environments.types.ts

@@ -0,0 +1,11 @@
+export type ProviderType = 'pm2' | 'docker' | 'eks';
+
+export interface Environment {
+  id: string;
+  name: string;
+  providerType: ProviderType;
+  envVars: Record<string, string>;
+  jsonConfig: Record<string, unknown>;
+  createdAt: string;
+  updatedAt: string;
+}

package/apps/fabric/src/environments/errors/environment.errors.ts

@@ -0,0 +1,14 @@
+import { HttpStatus } from '@nestjs/common';
+import { DomainError } from '@app/common';
+
+export class EnvironmentNotFoundError extends DomainError {
+  constructor(id: string) {
+    super(`Environment ${id} not found`, HttpStatus.NOT_FOUND);
+  }
+}
+
+export class EnvironmentAlreadyExistsError extends DomainError {
+  constructor(id: string) {
+    super(`Environment ${id} already exists`, HttpStatus.CONFLICT);
+  }
+}

package/apps/fabric/src/fabric-core.module.ts

@@ -0,0 +1,48 @@
+import { Module, DynamicModule } from '@nestjs/common';
+import { RouterModule } from '@nestjs/core';
+import { EmployeesModule } from './employees/employees.module';
+import { VersionsModule } from './versions/versions.module';
+import { HealthModule } from './health/health.module';
+import { EnvironmentsModule } from './environments/environments.module';
+import { DeploymentEventsModule } from './deployment-events/deployment-events.module';
+import { UserConfigModule } from './user-config/user-config.module';
+import { HealthcheckModule } from './healthcheck/healthcheck.module';
+import { ProjectsModule } from './projects/projects.module';
+import { DeploymentWatcherModule } from './watcher/deployment-watcher.module';
+
+const FABRIC_FEATURE_MODULES = [
+  EmployeesModule,
+  VersionsModule,
+  HealthModule,
+  EnvironmentsModule,
+  DeploymentEventsModule,
+  UserConfigModule,
+  HealthcheckModule,
+  ProjectsModule,
+  DeploymentWatcherModule,
+];
+
+@Module({})
+export class FabricCoreModule {
+  static forRoot(routePrefix?: string): DynamicModule {
+    const imports: any[] = [...FABRIC_FEATURE_MODULES];
+    if (routePrefix) {
+      imports.unshift(
+        RouterModule.register([
+          {
+            path: routePrefix,
+            children: FABRIC_FEATURE_MODULES.map((module) => ({
+              path: '',
+              module,
+            })),
+          },
+        ]),
+      );
+    }
+
+    return {
+      module: FabricCoreModule,
+      imports,
+    };
+  }
+}

package/apps/fabric/src/health/health.controller.ts

@@ -0,0 +1,19 @@
+import { Controller, Get } from '@nestjs/common';
+import { HealthCheck, HealthCheckService } from '@nestjs/terminus';
+import { ProviderHealthIndicator } from './provider-health.indicator';
+
+@Controller('health')
+export class HealthController {
+  constructor(
+    private readonly health: HealthCheckService,
+    private readonly providerHealth: ProviderHealthIndicator,
+  ) {}
+
+  @Get()
+  @HealthCheck()
+  check() {
+    return this.health.check([
+      () => this.providerHealth.isHealthy('deployment-provider'),
+    ]);
+  }
+}

package/apps/fabric/src/health/health.module.ts

@@ -0,0 +1,12 @@
+import { Module } from '@nestjs/common';
+import { TerminusModule } from '@nestjs/terminus';
+import { HealthController } from './health.controller';
+import { ProviderHealthIndicator } from './provider-health.indicator';
+import { ProvidersModule } from '../providers/providers.module';
+
+@Module({
+  imports: [TerminusModule, ProvidersModule],
+  controllers: [HealthController],
+  providers: [ProviderHealthIndicator],
+})
+export class HealthModule {}

package/apps/fabric/src/health/provider-health.indicator.ts

@@ -0,0 +1,33 @@
+import { Injectable, Inject } from '@nestjs/common';
+import {
+  HealthIndicator,
+  HealthIndicatorResult,
+  HealthCheckError,
+} from '@nestjs/terminus';
+import {
+  DEPLOYMENT_PROVIDER,
+  type DeploymentProvider,
+} from '../providers/provider.interface';
+
+@Injectable()
+export class ProviderHealthIndicator extends HealthIndicator {
+  constructor(
+    @Inject(DEPLOYMENT_PROVIDER)
+    private readonly provider: DeploymentProvider,
+  ) {
+    super();
+  }
+
+  async isHealthy(key: string): Promise<HealthIndicatorResult> {
+    const available = await this.provider.isAvailable();
+    const result = this.getStatus(key, available, {
+      type: this.provider.type,
+    });
+
+    if (available) {
+      return result;
+    }
+
+    throw new HealthCheckError('Provider unavailable', result);
+  }
+}

package/apps/fabric/src/healthcheck/healthcheck.module.ts

@@ -0,0 +1,24 @@
+import { Module, forwardRef } from '@nestjs/common';
+import { HealthcheckService } from './healthcheck.service';
+import { EmployeesModule } from '../employees/employees.module';
+import { DeploymentEventsModule } from '../deployment-events/deployment-events.module';
+import { UserConfigModule } from '../user-config/user-config.module';
+import { NotificationsModule } from '../notifications/notifications.module';
+import { AiAgentModule } from '../ai-agent/ai-agent.module';
+import { LogsModule } from '../logs/logs.module';
+import { ProvidersModule } from '../providers/providers.module';
+
+@Module({
+  imports: [
+    forwardRef(() => EmployeesModule),
+    DeploymentEventsModule,
+    UserConfigModule,
+    NotificationsModule,
+    AiAgentModule,
+    LogsModule,
+    ProvidersModule,
+  ],
+  providers: [HealthcheckService],
+  exports: [HealthcheckService],
+})
+export class HealthcheckModule {}