@agentlang/agentmanager 0.0.3

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

@@ -0,0 +1,69 @@
+export type Env = 'draft' | 'live';
+
+export type RuntimeStatus =
+  | 'pending'
+  | 'cloning'
+  | 'building'
+  | 'deploying'
+  | 'running'
+  | 'stopped'
+  | 'paused'
+  | 'crashed'
+  | 'failed'
+  | 'stopping';
+
+/** Runtimes that still hold live resources (used by deploy-all / undeploy). */
+export const ACTIVE_DEPLOYMENT_STATUSES: RuntimeStatus[] = [
+  'running',
+  'pending',
+  'cloning',
+  'building',
+  'deploying',
+  'paused',
+];
+
+export interface RuntimeInfo {
+  runtime: RuntimeStatus;
+  deployedAt: string | null;
+  lastError: string | null;
+}
+
+export interface DraftRuntimeInfo extends RuntimeInfo {
+  moduleCount: number;
+}
+
+export interface LiveRuntimeInfo extends RuntimeInfo {
+  versionId: string | null;
+  publishedAt: string | null;
+}
+
+export interface EmployeeStatus {
+  projectId: string;
+  employeeId: string;
+  draft: DraftRuntimeInfo;
+  live: LiveRuntimeInfo;
+  draftAheadOfLive: boolean;
+}
+
+export interface DeployResult {
+  projectId: string;
+  employeeId: string;
+  env: Env;
+  runtime: RuntimeStatus;
+  deployedAt: string;
+  versionId?: string;
+  containerId?: string;
+  port?: number;
+  environmentId?: string;
+}
+
+export interface ResolveResult {
+  projectId: string;
+  employeeId: string;
+  env: Env;
+  runtime: RuntimeStatus;
+  endpoint: string | null;
+  port: number | null;
+  containerId: string | null;
+  capabilities: string[];
+}

package/apps/fabric/src/employees/errors/employee-deployment.errors.ts

@@ -0,0 +1,80 @@
+import { HttpStatus } from '@nestjs/common';
+import { DomainError } from '@app/common';
+
+export class EmployeeNotFoundError extends DomainError {
+  constructor(projectId: string, employeeId: string) {
+    super(
+      `Employee ${employeeId} not found in project ${projectId}`,
+      HttpStatus.NOT_FOUND,
+    );
+  }
+}
+
+export class NoLiveVersionError extends DomainError {
+  constructor(projectId: string, employeeId: string) {
+    super(
+      `Employee ${employeeId} in project ${projectId} has no published version`,
+      HttpStatus.CONFLICT,
+    );
+  }
+}
+
+export class VersionNotFoundError extends DomainError {
+  constructor(projectId: string, employeeId: string, versionId: string) {
+    super(
+      `Version ${versionId} not found for employee ${employeeId} in project ${projectId}`,
+      HttpStatus.NOT_FOUND,
+    );
+  }
+}
+
+export class AlreadyInStateError extends DomainError {
+  constructor(employeeId: string, env: string, state: string) {
+    super(
+      `Employee ${employeeId} (${env}) is already ${state}`,
+      HttpStatus.CONFLICT,
+    );
+  }
+}
+
+export class CannotRemoveError extends DomainError {
+  constructor(employeeId: string, env: string, currentState: string) {
+    super(
+      `Cannot remove employee ${employeeId} (${env}) while in state "${currentState}". Must be stopped, failed, or crashed.`,
+      HttpStatus.CONFLICT,
+    );
+  }
+}
+
+export class InvalidStateTransitionError extends DomainError {
+  constructor(employeeId: string, env: string, from: string, to: string) {
+    super(
+      `Cannot transition employee ${employeeId} (${env}) from ${from} to ${to}`,
+      HttpStatus.CONFLICT,
+    );
+  }
+}
+
+export class DeploymentEnvironmentMismatchError extends DomainError {
+  constructor(
+    projectId: string,
+    employeeId: string,
+    track: string,
+    expectedEnvironmentId: string,
+    receivedEnvironmentId: string,
+  ) {
+    super(
+      `Fabric environment id mismatch for ${projectId}/${employeeId} (${track}): expected ${expectedEnvironmentId}, got ${receivedEnvironmentId}`,
+      HttpStatus.BAD_REQUEST,
+    );
+  }
+}
+
+export class UndeployEnvironmentUnresolvedError extends DomainError {
+  constructor(projectId: string, employeeId: string, track: string) {
+    super(
+      `Cannot undeploy ${projectId}/${employeeId} (${track}): no Fabric environment id on deployment, project, or request`,
+      HttpStatus.BAD_REQUEST,
+    );
+  }
+}

package/apps/fabric/src/employees/runtime.store.ts

@@ -0,0 +1,304 @@
+import {
+  Injectable,
+  OnModuleInit,
+  OnModuleDestroy,
+  Logger,
+} from '@nestjs/common';
+import type { Repository } from 'typeorm';
+import { FileStoreFactory, FileStore, DataSourceService } from '@app/common';
+import { RuntimeEntity } from '../database/entities';
+import type {
+  Env,
+  RuntimeStatus,
+  DraftRuntimeInfo,
+  LiveRuntimeInfo,
+} from './employees.types';
+
+export interface RuntimeEntry {
+  userId: string | null;
+  runtime: RuntimeStatus;
+  deployedAt: string | null;
+  lastError: string | null;
+  versionId: string | null;
+  publishedAt: string | null;
+  moduleCount: number;
+  containerId: string | null;
+  port: number | null;
+  environmentId: string | null;
+  projectPath: string | null;
+  source: unknown;
+  healthcheckRetryCount: number;
+  envVars: Record<string, string> | null;
+}
+
+interface PersistedData {
+  entries: Record<string, RuntimeEntry>;
+}
+
+@Injectable()
+export class RuntimeStore implements OnModuleInit, OnModuleDestroy {
+  private readonly logger = new Logger(RuntimeStore.name);
+  private readonly entries = new Map<string, RuntimeEntry>();
+  private readonly fileStore: FileStore<PersistedData>;
+  private repo: Repository<RuntimeEntity> | null = null;
+
+  constructor(
+    fileStoreFactory: FileStoreFactory,
+    private readonly dataSourceService: DataSourceService,
+  ) {
+    this.fileStore = fileStoreFactory.create<PersistedData>('runtime.json');
+  }
+
+  async onModuleInit() {
+    this.repo = this.dataSourceService.getRepository(RuntimeEntity);
+
+    if (this.repo) {
+      const rows = await this.repo.find();
+      for (const row of rows) {
+        const key = this.key(row.projectId, row.employeeId, row.env as Env);
+        this.entries.set(key, this.entityToEntry(row));
+      }
+      this.logger.log(
+        `Loaded ${this.entries.size} runtime entries from database`,
+      );
+    } else {
+      const data = await this.fileStore.load();
+      if (data?.entries) {
+        for (const [key, entry] of Object.entries(data.entries)) {
+          this.entries.set(key, entry);
+        }
+        this.logger.log(
+          `Loaded ${this.entries.size} runtime entries from disk`,
+        );
+      }
+    }
+  }
+
+  private entityToEntry(entity: RuntimeEntity): RuntimeEntry {
+    return {
+      userId: entity.userId,
+      runtime: entity.runtime as RuntimeStatus,
+      deployedAt: entity.deployedAt,
+      lastError: entity.lastError,
+      versionId: entity.versionId,
+      publishedAt: entity.publishedAt,
+      moduleCount: entity.moduleCount,
+      containerId: entity.containerId,
+      port: entity.port,
+      environmentId: entity.environmentId,
+      projectPath: entity.projectPath,
+      source: entity.source,
+      healthcheckRetryCount: entity.healthcheckRetryCount,
+      envVars: entity.envVars,
+    };
+  }
+
+  private entryToEntity(
+    projectId: string,
+    employeeId: string,
+    env: string,
+    entry: RuntimeEntry,
+  ): RuntimeEntity {
+    const entity = new RuntimeEntity();
+    entity.projectId = projectId;
+    entity.employeeId = employeeId;
+    entity.env = env;
+    entity.userId = entry.userId;
+    entity.runtime = entry.runtime;
+    entity.deployedAt = entry.deployedAt;
+    entity.lastError = entry.lastError;
+    entity.versionId = entry.versionId;
+    entity.publishedAt = entry.publishedAt;
+    entity.moduleCount = entry.moduleCount;
+    entity.containerId = entry.containerId;
+    entity.port = entry.port;
+    entity.environmentId = entry.environmentId;
+    entity.projectPath = entry.projectPath;
+    entity.source = entry.source;
+    entity.healthcheckRetryCount = entry.healthcheckRetryCount;
+    entity.envVars = entry.envVars;
+    return entity;
+  }
+
+  private persist(projectId?: string, employeeId?: string, env?: string): void {
+    if (this.repo && projectId && employeeId && env) {
+      const entry = this.entries.get(
+        this.key(projectId, employeeId, env as Env),
+      );
+      if (entry) {
+        this.repo
+          .save(this.entryToEntity(projectId, employeeId, env, entry))
+          .catch((err) =>
+            this.logger.error(`Failed to persist runtime entry: ${err}`),
+          );
+      }
+    } else if (!this.repo) {
+      const entries: Record<string, RuntimeEntry> = {};
+      for (const [key, entry] of this.entries) {
+        entries[key] = entry;
+      }
+      this.fileStore.save({ entries });
+    }
+  }
+
+  private persistDelete(
+    projectId: string,
+    employeeId: string,
+    env: string,
+  ): void {
+    if (this.repo) {
+      this.repo
+        .delete({ projectId, employeeId, env })
+        .catch((err) =>
+          this.logger.error(`Failed to delete runtime entry: ${err}`),
+        );
+    }
+  }
+
+  private key(projectId: string, employeeId: string, env: Env): string {
+    return `${projectId}/${employeeId}/${env}`;
+  }
+
+  get(
+    projectId: string,
+    employeeId: string,
+    env: Env,
+  ): RuntimeEntry | undefined {
+    return this.entries.get(this.key(projectId, employeeId, env));
+  }
+
+  set(
+    projectId: string,
+    employeeId: string,
+    env: Env,
+    entry: RuntimeEntry,
+  ): void {
+    this.entries.set(this.key(projectId, employeeId, env), entry);
+    this.persist(projectId, employeeId, env);
+  }
+
+  updateField(
+    projectId: string,
+    employeeId: string,
+    env: string,
+    fields: Partial<RuntimeEntry>,
+  ): void {
+    const key = this.key(projectId, employeeId, env as Env);
+    const existing = this.entries.get(key);
+    if (!existing) return;
+    this.entries.set(key, { ...existing, ...fields });
+    this.persist(projectId, employeeId, env);
+  }
+
+  delete(projectId: string, employeeId: string, env: Env): boolean {
+    const result = this.entries.delete(this.key(projectId, employeeId, env));
+    if (result) {
+      this.persistDelete(projectId, employeeId, env);
+    }
+    if (!this.repo) {
+      this.persist();
+    }
+    return result;
+  }
+
+  getUsedPorts(): Set<number> {
+    const ports = new Set<number>();
+    for (const entry of this.entries.values()) {
+      if (entry.port !== null) {
+        ports.add(entry.port);
+      }
+    }
+    return ports;
+  }
+
+  listByProject(
+    projectId: string,
+  ): Array<{ employeeId: string; env: Env; entry: RuntimeEntry }> {
+    const prefix = `${projectId}/`;
+    const results: Array<{
+      employeeId: string;
+      env: Env;
+      entry: RuntimeEntry;
+    }> = [];
+    for (const [k, entry] of this.entries) {
+      if (k.startsWith(prefix)) {
+        const parts = k.split('/');
+        results.push({
+          employeeId: parts[1],
+          env: parts[2] as Env,
+          entry,
+        });
+      }
+    }
+    return results;
+  }
+
+  listAll(): Array<{
+    projectId: string;
+    employeeId: string;
+    env: Env;
+    entry: RuntimeEntry;
+  }> {
+    const results: Array<{
+      projectId: string;
+      employeeId: string;
+      env: Env;
+      entry: RuntimeEntry;
+    }> = [];
+    for (const [k, entry] of this.entries) {
+      const parts = k.split('/');
+      results.push({
+        projectId: parts[0],
+        employeeId: parts[1],
+        env: parts[2] as Env,
+        entry,
+      });
+    }
+    return results;
+  }
+
+  toDraftInfo(entry: RuntimeEntry | undefined): DraftRuntimeInfo {
+    if (!entry) {
+      return {
+        runtime: 'stopped',
+        deployedAt: null,
+        lastError: null,
+        moduleCount: 0,
+      };
+    }
+    return {
+      runtime: entry.runtime,
+      deployedAt: entry.deployedAt,
+      lastError: entry.lastError,
+      moduleCount: entry.moduleCount,
+    };
+  }
+
+  toLiveInfo(entry: RuntimeEntry | undefined): LiveRuntimeInfo {
+    if (!entry) {
+      return {
+        runtime: 'stopped',
+        deployedAt: null,
+        lastError: null,
+        versionId: null,
+        publishedAt: null,
+      };
+    }
+    return {
+      runtime: entry.runtime,
+      deployedAt: entry.deployedAt,
+      lastError: entry.lastError,
+      versionId: entry.versionId,
+      publishedAt: entry.publishedAt,
+    };
+  }
+
+  async onModuleDestroy() {
+    if (!this.repo) {
+      await this.fileStore.flush();
+    }
+    this.logger.log(
+      `RuntimeStore shutting down with ${this.entries.size} entries`,
+    );
+  }
+}

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

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+import { createZodDto } from 'nestjs-zod';
+
+export const CreateEnvironmentSchema = z.object({
+  /** When set, this id is used instead of an auto-generated `env-N` id. */
+  id: z.string().min(1).optional(),
+  name: z.string().min(1),
+  providerType: z.enum(['pm2', 'docker', 'eks']),
+  envVars: z.record(z.string(), z.string()).default({}),
+  jsonConfig: z.record(z.string(), z.unknown()).default({}),
+});
+
+export class CreateEnvironmentDto extends createZodDto(
+  CreateEnvironmentSchema,
+) {}
+
+export const UpdateEnvironmentSchema = z.object({
+  name: z.string().min(1).optional(),
+  providerType: z.enum(['pm2', 'docker', 'eks']).optional(),
+  envVars: z.record(z.string(), z.string()).optional(),
+  jsonConfig: z.record(z.string(), z.unknown()).optional(),
+});
+
+export class UpdateEnvironmentDto extends createZodDto(
+  UpdateEnvironmentSchema,
+) {}

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

@@ -0,0 +1,48 @@
+import {
+  Controller,
+  Get,
+  Post,
+  Patch,
+  Delete,
+  Param,
+  Body,
+  HttpCode,
+  HttpStatus,
+} from '@nestjs/common';
+import { EnvironmentsService } from './environments.service';
+import {
+  CreateEnvironmentDto,
+  UpdateEnvironmentDto,
+} from './dto/environment.dto';
+
+@Controller('environments')
+export class EnvironmentsController {
+  constructor(private readonly environmentsService: EnvironmentsService) {}
+
+  @Post()
+  @HttpCode(HttpStatus.CREATED)
+  create(@Body() dto: CreateEnvironmentDto) {
+    return this.environmentsService.create(dto);
+  }
+
+  @Get()
+  list() {
+    return { data: this.environmentsService.list() };
+  }
+
+  @Get(':id')
+  get(@Param('id') id: string) {
+    return this.environmentsService.get(id);
+  }
+
+  @Patch(':id')
+  update(@Param('id') id: string, @Body() dto: UpdateEnvironmentDto) {
+    return this.environmentsService.update(id, dto);
+  }
+
+  @Delete(':id')
+  @HttpCode(HttpStatus.NO_CONTENT)
+  delete(@Param('id') id: string): void {
+    this.environmentsService.delete(id);
+  }
+}

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

@@ -0,0 +1,11 @@
+import { Module } from '@nestjs/common';
+import { EnvironmentsController } from './environments.controller';
+import { EnvironmentsService } from './environments.service';
+import { EnvironmentsStore } from './environments.store';
+
+@Module({
+  controllers: [EnvironmentsController],
+  providers: [EnvironmentsService, EnvironmentsStore],
+  exports: [EnvironmentsService],
+})
+export class EnvironmentsModule {}

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

@@ -0,0 +1,92 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { EnvironmentsStore } from './environments.store';
+import {
+  EnvironmentAlreadyExistsError,
+  EnvironmentNotFoundError,
+} from './errors/environment.errors';
+import type { Environment, ProviderType } from './environments.types';
+
+@Injectable()
+export class EnvironmentsService {
+  private readonly logger = new Logger(EnvironmentsService.name);
+
+  constructor(private readonly store: EnvironmentsStore) {}
+
+  create(data: {
+    id?: string;
+    name: string;
+    providerType: ProviderType;
+    envVars: Record<string, string>;
+    jsonConfig: Record<string, unknown>;
+  }): Environment {
+    const id =
+      data.id != null && data.id.trim() !== ''
+        ? data.id.trim()
+        : this.store.generateId();
+
+    if (this.store.get(id)) {
+      throw new EnvironmentAlreadyExistsError(id);
+    }
+
+    const now = new Date().toISOString();
+    const env: Environment = {
+      id,
+      name: data.name,
+      providerType: data.providerType,
+      envVars: data.envVars,
+      jsonConfig: data.jsonConfig,
+      createdAt: now,
+      updatedAt: now,
+    };
+
+    this.store.set(env);
+    this.logger.log(`Created environment ${env.id} (${env.name})`);
+    return env;
+  }
+
+  list(): Environment[] {
+    return this.store.list();
+  }
+
+  get(id: string): Environment {
+    const env = this.store.get(id);
+    if (!env) {
+      throw new EnvironmentNotFoundError(id);
+    }
+    return env;
+  }
+
+  update(
+    id: string,
+    data: Partial<{
+      name: string;
+      providerType: ProviderType;
+      envVars: Record<string, string>;
+      jsonConfig: Record<string, unknown>;
+    }>,
+  ): Environment {
+    const existing = this.get(id);
+    const updated: Environment = {
+      ...existing,
+      ...data,
+      updatedAt: new Date().toISOString(),
+    };
+
+    this.store.set(updated);
+    this.logger.log(`Updated environment ${id}`);
+    return updated;
+  }
+
+  delete(id: string): void {
+    const exists = this.store.get(id);
+    if (!exists) {
+      throw new EnvironmentNotFoundError(id);
+    }
+    this.store.delete(id);
+    this.logger.log(`Deleted environment ${id}`);
+  }
+
+  getProviderType(id: string): ProviderType {
+    return this.get(id).providerType;
+  }
+}