@agentlang/agentmanager 0.0.3

package/apps/fabric/src/deployment-events/deployment-events.store.ts

@@ -0,0 +1,162 @@
+import {
+  Injectable,
+  OnModuleInit,
+  OnModuleDestroy,
+  Logger,
+} from '@nestjs/common';
+import type { Repository } from 'typeorm';
+import { FileStoreFactory, FileStore, DataSourceService } from '@app/common';
+import { DeploymentEventEntity } from '../database/entities';
+import type { DeploymentEvent } from './deployment-events.types';
+
+interface PersistedData {
+  counter: number;
+  events: DeploymentEvent[];
+}
+
+@Injectable()
+export class DeploymentEventsStore implements OnModuleInit, OnModuleDestroy {
+  private readonly logger = new Logger(DeploymentEventsStore.name);
+  private readonly events: DeploymentEvent[] = [];
+  private readonly fileStore: FileStore<PersistedData>;
+  private counter = 0;
+  private repo: Repository<DeploymentEventEntity> | null = null;
+
+  constructor(
+    fileStoreFactory: FileStoreFactory,
+    private readonly dataSourceService: DataSourceService,
+  ) {
+    this.fileStore = fileStoreFactory.create<PersistedData>(
+      'deployment-events.json',
+    );
+  }
+
+  async onModuleInit() {
+    this.repo = this.dataSourceService.getRepository(DeploymentEventEntity);
+
+    if (this.repo) {
+      const rows = await this.repo.find({
+        order: { createdAt: 'ASC' },
+      });
+      for (const row of rows) {
+        this.events.push(this.entityToEvent(row));
+      }
+      // Derive counter from existing IDs
+      for (const event of this.events) {
+        const match = event.id.match(/^evt-(\d+)$/);
+        if (match) {
+          this.counter = Math.max(this.counter, parseInt(match[1], 10));
+        }
+      }
+      this.logger.log(
+        `Loaded ${this.events.length} deployment events from database`,
+      );
+    } else {
+      const data = await this.fileStore.load();
+      if (data) {
+        this.counter = data.counter ?? 0;
+        this.events.push(...(data.events ?? []));
+        this.logger.log(
+          `Loaded ${this.events.length} deployment events from disk`,
+        );
+      }
+    }
+  }
+
+  private entityToEvent(entity: DeploymentEventEntity): DeploymentEvent {
+    return {
+      id: entity.id,
+      userId: entity.userId,
+      projectId: entity.projectId,
+      employeeId: entity.employeeId,
+      env: entity.env,
+      type: entity.type as DeploymentEvent['type'],
+      message: entity.message,
+      retryCount: entity.retryCount ?? undefined,
+      createdAt: entity.createdAt,
+    };
+  }
+
+  private eventToEntity(event: DeploymentEvent): DeploymentEventEntity {
+    const entity = new DeploymentEventEntity();
+    entity.id = event.id;
+    entity.userId = event.userId;
+    entity.projectId = event.projectId;
+    entity.employeeId = event.employeeId;
+    entity.env = event.env;
+    entity.type = event.type;
+    entity.message = event.message;
+    entity.retryCount = event.retryCount;
+    entity.createdAt = event.createdAt;
+    return entity;
+  }
+
+  private persist(): void {
+    if (!this.repo) {
+      this.fileStore.save({ counter: this.counter, events: this.events });
+    }
+  }
+
+  generateId(): string {
+    this.counter += 1;
+    return `evt-${this.counter}`;
+  }
+
+  create(event: DeploymentEvent): DeploymentEvent {
+    this.events.push(event);
+    if (this.repo) {
+      this.repo
+        .save(this.eventToEntity(event))
+        .catch((err) =>
+          this.logger.error(`Failed to persist deployment event: ${err}`),
+        );
+    } else {
+      this.persist();
+    }
+    return event;
+  }
+
+  getAll(options?: {
+    projectId?: string;
+    employeeId?: string;
+    userId?: string;
+    limit?: number;
+  }): DeploymentEvent[] {
+    let results = [...this.events];
+
+    if (options?.projectId) {
+      results = results.filter((e) => e.projectId === options.projectId);
+    }
+    if (options?.employeeId) {
+      results = results.filter((e) => e.employeeId === options.employeeId);
+    }
+    if (options?.userId) {
+      results = results.filter((e) => e.userId === options.userId);
+    }
+
+    results.sort(
+      (a, b) =>
+        new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime(),
+    );
+
+    const limit = options?.limit ?? 500;
+    return results.slice(0, limit);
+  }
+
+  getByProjectAndEmployee(
+    projectId: string,
+    employeeId: string,
+    options?: { limit?: number },
+  ): DeploymentEvent[] {
+    return this.getAll({ projectId, employeeId, limit: options?.limit });
+  }
+
+  async onModuleDestroy() {
+    if (!this.repo) {
+      await this.fileStore.flush();
+    }
+    this.logger.log(
+      `DeploymentEventsStore shutting down with ${this.events.length} events`,
+    );
+  }
+}

package/apps/fabric/src/deployment-events/deployment-events.types.ts

@@ -0,0 +1,24 @@
+export type DeploymentEventType =
+  | 'start'
+  | 'restart'
+  | 'stop'
+  | 'error'
+  | 'remove'
+  | 'healthcheck_failed'
+  | 'healthcheck_retry'
+  | 'healthcheck_exhausted'
+  | 'watcher_recover'
+  | 'probe_restart'
+  | 'probe_escalate';
+
+export interface DeploymentEvent {
+  id: string;
+  userId: string | null;
+  projectId: string;
+  employeeId: string;
+  env: string;
+  type: DeploymentEventType;
+  message: string;
+  retryCount?: number;
+  createdAt: string;
+}

package/apps/fabric/src/employees/dto/deploy.dto.ts

@@ -0,0 +1,71 @@
+import { z } from 'zod';
+import { createZodDto } from 'nestjs-zod';
+
+const SourceSchema = z.discriminatedUnion('type', [
+  z.object({
+    type: z.literal('github'),
+    org: z.string().min(1),
+    repo: z.string().min(1),
+    branch: z.string().optional(),
+  }),
+  z.object({
+    type: z.literal('local'),
+    path: z.string().min(1),
+  }),
+]);
+
+/** draft/live deployment slot (stop, pause, resume, restart). */
+export const RuntimeTrackSchema = z.object({
+  env: z.enum(['draft', 'live']),
+});
+
+export class RuntimeTrackDto extends createZodDto(RuntimeTrackSchema) {}
+
+/**
+ * POST …/deploy — `env` is the Fabric environment id (resolved via Environments API).
+ * `track` selects the draft vs live runtime slot.
+ */
+export const DeployRequestSchema = z.object({
+  env: z.string().min(1),
+  track: z.enum(['draft', 'live']).default('draft'),
+  source: SourceSchema.optional(),
+});
+
+export class DeployRequestDto extends createZodDto(DeployRequestSchema) {}
+
+/**
+ * POST …/undeploy — same shape as deploy (minus `source`): `env` is the Fabric
+ * environment id; `track` selects the draft vs live runtime slot.
+ */
+export const UndeployRequestSchema = z.object({
+  env: z.string().min(1),
+  track: z.enum(['draft', 'live']).default('draft'),
+});
+
+export class UndeployRequestDto extends createZodDto(UndeployRequestSchema) {}
+
+export const EnvQuerySchema = z.object({
+  env: z.enum(['draft', 'live']).optional(),
+  tail: z.coerce.number().int().positive().optional(),
+});
+
+export class EnvQueryDto extends createZodDto(EnvQuerySchema) {}
+
+export const RollbackSchema = z.object({
+  versionId: z.string().optional(),
+});
+
+export class RollbackDto extends createZodDto(RollbackSchema) {}
+
+export const LogQuerySchema = z.object({
+  /** draft/live runtime slot (preferred; aligns with POST …/deploy `track`). */
+  track: z.enum(['draft', 'live']).optional(),
+  /** @deprecated use `track` — same meaning as `track` (draft vs live slot). */
+  env: z.enum(['draft', 'live']).optional(),
+  /** `stdout`: live process/container logs (PM2 or Docker); `file`: rotated app log files on disk. */
+  type: z.enum(['stdout', 'file']).optional(),
+  date: z.string().optional(),
+  tail: z.coerce.number().int().positive().optional(),
+});
+
+export class LogQueryDto extends createZodDto(LogQuerySchema) {}

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

@@ -0,0 +1,217 @@
+import {
+  Controller,
+  Get,
+  Post,
+  Delete,
+  Param,
+  Body,
+  Query,
+  HttpCode,
+  HttpStatus,
+} from '@nestjs/common';
+import { EmployeesService } from './employees.service';
+import {
+  DeployRequestDto,
+  UndeployRequestDto,
+  RuntimeTrackDto,
+  EnvQueryDto,
+  RollbackDto,
+  LogQueryDto,
+} from './dto/deploy.dto';
+import { CurrentUser } from '../auth/current-user.decorator';
+
+@Controller('projects/:projectId/employees')
+export class EmployeesController {
+  constructor(private readonly employeesService: EmployeesService) {}
+
+  // ── Runtime lifecycle ──────────────────────────────────────────────
+
+  @Post(':employeeId/deploy')
+  @HttpCode(HttpStatus.ACCEPTED)
+  async deploy(
+    @Param('projectId') projectId: string,
+    @Param('employeeId') employeeId: string,
+    @Body() dto: DeployRequestDto,
+    @CurrentUser('userId') userId: string,
+  ) {
+    return this.employeesService.deploy(
+      projectId,
+      employeeId,
+      dto.track,
+      dto.env,
+      dto.source,
+      userId,
+    );
+  }
+
+  @Post(':employeeId/undeploy')
+  @HttpCode(HttpStatus.OK)
+  async undeploy(
+    @Param('projectId') projectId: string,
+    @Param('employeeId') employeeId: string,
+    @Body() dto: UndeployRequestDto,
+  ) {
+    return this.employeesService.undeploy(
+      projectId,
+      employeeId,
+      dto.track,
+      dto.env,
+    );
+  }
+
+  @Post(':employeeId/stop')
+  @HttpCode(HttpStatus.OK)
+  async stop(
+    @Param('projectId') projectId: string,
+    @Param('employeeId') employeeId: string,
+    @Body() dto: RuntimeTrackDto,
+  ) {
+    return this.employeesService.stop(projectId, employeeId, dto.env);
+  }
+
+  @Post(':employeeId/pause')
+  @HttpCode(HttpStatus.OK)
+  async pause(
+    @Param('projectId') projectId: string,
+    @Param('employeeId') employeeId: string,
+    @Body() dto: RuntimeTrackDto,
+  ) {
+    return this.employeesService.pause(projectId, employeeId, dto.env);
+  }
+
+  @Post(':employeeId/resume')
+  @HttpCode(HttpStatus.ACCEPTED)
+  async resume(
+    @Param('projectId') projectId: string,
+    @Param('employeeId') employeeId: string,
+    @Body() dto: RuntimeTrackDto,
+  ) {
+    return this.employeesService.resume(projectId, employeeId, dto.env);
+  }
+
+  @Post(':employeeId/restart')
+  @HttpCode(HttpStatus.OK)
+  async restart(
+    @Param('projectId') projectId: string,
+    @Param('employeeId') employeeId: string,
+    @Body() dto: RuntimeTrackDto,
+  ) {
+    return this.employeesService.restart(projectId, employeeId, dto.env);
+  }
+
+  // ── Publishing ─────────────────────────────────────────────────────
+
+  @Post(':employeeId/publish')
+  @HttpCode(HttpStatus.ACCEPTED)
+  async publish(
+    @Param('projectId') projectId: string,
+    @Param('employeeId') employeeId: string,
+  ) {
+    return this.employeesService.publish(projectId, employeeId);
+  }
+
+  @Post(':employeeId/unpublish')
+  @HttpCode(HttpStatus.OK)
+  async unpublish(
+    @Param('projectId') projectId: string,
+    @Param('employeeId') employeeId: string,
+  ) {
+    return this.employeesService.unpublish(projectId, employeeId);
+  }
+
+  @Post(':employeeId/rollback')
+  @HttpCode(HttpStatus.ACCEPTED)
+  async rollback(
+    @Param('projectId') projectId: string,
+    @Param('employeeId') employeeId: string,
+    @Body() dto: RollbackDto,
+  ) {
+    return this.employeesService.rollback(projectId, employeeId, dto.versionId);
+  }
+
+  // ── Removal ───────────────────────────────────────────────────────
+
+  @Delete(':employeeId')
+  @HttpCode(HttpStatus.OK)
+  async remove(
+    @Param('projectId') projectId: string,
+    @Param('employeeId') employeeId: string,
+    @Query() query: EnvQueryDto,
+  ) {
+    return this.employeesService.remove(
+      projectId,
+      employeeId,
+      query.env ?? 'draft',
+    );
+  }
+
+  // ── Status ─────────────────────────────────────────────────────────
+
+  @Get('status')
+  bulkStatus(@Param('projectId') projectId: string) {
+    return { data: this.employeesService.getBulkStatus(projectId) };
+  }
+
+  @Get(':employeeId/status')
+  status(
+    @Param('projectId') projectId: string,
+    @Param('employeeId') employeeId: string,
+  ) {
+    return this.employeesService.getStatus(projectId, employeeId);
+  }
+
+  // ── Health ─────────────────────────────────────────────────────────
+
+  @Get(':employeeId/health')
+  async health(
+    @Param('projectId') projectId: string,
+    @Param('employeeId') employeeId: string,
+    @Query() query: EnvQueryDto,
+  ) {
+    return this.employeesService.checkHealth(
+      projectId,
+      employeeId,
+      query.env ?? 'draft',
+    );
+  }
+
+  // ── Logs ────────────────────────────────────────────────────────────
+
+  /**
+   * Deployment stdout logs from the runtime provider (PM2 process or Docker container),
+   * or file-based logs under the project path when `type=file`.
+   */
+  @Get(':employeeId/logs')
+  async logs(
+    @Param('projectId') projectId: string,
+    @Param('employeeId') employeeId: string,
+    @Query() query: LogQueryDto,
+  ) {
+    const track = query.track ?? query.env ?? 'draft';
+    return this.employeesService.getLogs(projectId, employeeId, track, {
+      type: query.type,
+      date: query.date,
+      tail: query.tail,
+    });
+  }
+
+  // ── Runtime resolution (internal) ─────────────────────────────────
+
+  /**
+   * Resolves listen URL/port for a deployment. Query `env` is the runtime slot
+   * (`draft` | `live`), same as stop/health/logs — defaults to **draft** so it
+   * matches typical `POST …/deploy` without `?env=`.
+   */
+  @Get(':employeeId/resolve')
+  resolve(
+    @Param('projectId') projectId: string,
+    @Param('employeeId') employeeId: string,
+    @Query() query: EnvQueryDto,
+  ) {
+    return this.employeesService.resolve(
+      projectId,
+      employeeId,
+      query.env ?? 'draft',
+    );
+  }
+}

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

@@ -0,0 +1,32 @@
+import { Module, forwardRef } from '@nestjs/common';
+import { EmployeesController } from './employees.controller';
+import { EmployeesService } from './employees.service';
+import { RuntimeStore } from './runtime.store';
+import { PortAllocator } from '../providers/port-allocator';
+import { VersionsModule } from '../versions/versions.module';
+import { ProvidersModule } from '../providers/providers.module';
+import { EnvironmentsModule } from '../environments/environments.module';
+import { ProjectSourceModule } from '../project-source/project-source.module';
+import { DeploymentEventsModule } from '../deployment-events/deployment-events.module';
+import { LogsModule } from '../logs/logs.module';
+import { NotificationsModule } from '../notifications/notifications.module';
+import { ProvisionersModule } from '../provisioners/provisioners.module';
+import { ProjectsModule } from '../projects/projects.module';
+
+@Module({
+  imports: [
+    VersionsModule,
+    ProvidersModule,
+    EnvironmentsModule,
+    ProjectSourceModule,
+    DeploymentEventsModule,
+    LogsModule,
+    NotificationsModule,
+    ProvisionersModule,
+    forwardRef(() => ProjectsModule),
+  ],
+  controllers: [EmployeesController],
+  providers: [EmployeesService, RuntimeStore, PortAllocator],
+  exports: [EmployeesService, RuntimeStore],
+})
+export class EmployeesModule {}