@agentlang/agentmanager 0.0.3

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

@@ -0,0 +1,23 @@
+import { Module } from '@nestjs/common';
+import { NotificationsService, SES_MODULE } from './notifications.service';
+import { UserConfigModule } from '../user-config/user-config.module';
+
+@Module({
+  imports: [UserConfigModule],
+  providers: [
+    NotificationsService,
+    {
+      provide: SES_MODULE,
+      useFactory: async () => {
+        try {
+          const name = '@aws-sdk/client-ses';
+          return (await import(name)) as unknown;
+        } catch {
+          return null;
+        }
+      },
+    },
+  ],
+  exports: [NotificationsService],
+})
+export class NotificationsModule {}

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

@@ -0,0 +1,141 @@
+import { Injectable, Inject, Logger } from '@nestjs/common';
+import type { ConfigType } from '@nestjs/config';
+import fabricConfig from '../config/configuration';
+import { UserConfigService } from '../user-config/user-config.service';
+
+export const SES_MODULE = Symbol('SES_MODULE');
+
+interface SesModule {
+  SESClient: new (opts: { region: string }) => {
+    send: (command: unknown) => Promise<void>;
+  };
+  SendEmailCommand: new (params: Record<string, unknown>) => unknown;
+}
+
+export interface FailureNotificationPayload {
+  projectId: string;
+  employeeId: string;
+  env: string;
+  type: 'error' | 'healthcheck_exhausted' | 'healthcheck_failed';
+  message: string;
+  retryCount?: number;
+}
+
+export interface EscalationEmailPayload {
+  subject: string;
+  body: string;
+}
+
+@Injectable()
+export class NotificationsService {
+  private readonly logger = new Logger(NotificationsService.name);
+
+  constructor(
+    @Inject(fabricConfig.KEY)
+    private readonly config: ConfigType<typeof fabricConfig>,
+    private readonly userConfigService: UserConfigService,
+    @Inject(SES_MODULE) private readonly sesModule: SesModule | null,
+  ) {}
+
+  /**
+   * Human escalation for probe failures (SES). Requires `SES_FROM_EMAIL` and
+   * `FABRIC_ESCALATION_TO_EMAIL` (or `SES_ESCALATION_TO_EMAIL`) in config / env.
+   */
+  async sendEscalationEmail(payload: EscalationEmailPayload): Promise<void> {
+    const fromEmail = this.config.ses.fromEmail;
+    const toEmail = this.config.ses.escalationToEmail;
+    if (!fromEmail || !toEmail) {
+      this.logger.warn(
+        'sendEscalationEmail: SES_FROM_EMAIL and FABRIC_ESCALATION_TO_EMAIL must be set',
+      );
+      return;
+    }
+    if (!this.sesModule) {
+      this.logger.warn(
+        '@aws-sdk/client-ses not installed, skipping escalation email',
+      );
+      return;
+    }
+    try {
+      const ses = this.sesModule;
+      const client = new ses.SESClient({ region: this.config.aws.region });
+      const command = new ses.SendEmailCommand({
+        Source: fromEmail,
+        Destination: { ToAddresses: [toEmail] },
+        Message: {
+          Subject: { Data: payload.subject, Charset: 'UTF-8' },
+          Body: { Text: { Data: payload.body, Charset: 'UTF-8' } },
+        },
+      });
+      await client.send(command);
+      this.logger.log(`Sent escalation email to ${toEmail}`);
+    } catch (err) {
+      this.logger.error(`sendEscalationEmail failed: ${err}`);
+    }
+  }
+
+  async notifyOnFailure(
+    userId: string,
+    payload: FailureNotificationPayload,
+  ): Promise<void> {
+    try {
+      const config = this.userConfigService.getNotificationConfig(userId);
+      const fromEmail = config.fromEmail ?? this.config.ses.fromEmail ?? null;
+      const toEmails = config.toEmails.length > 0 ? config.toEmails : [];
+
+      if (!fromEmail || toEmails.length === 0) return;
+
+      await this.sendFailureEmail(fromEmail, toEmails, payload);
+    } catch (err) {
+      this.logger.error(`notifyOnFailure error: ${err}`);
+    }
+  }
+
+  private async sendFailureEmail(
+    fromEmail: string,
+    toEmails: string[],
+    payload: FailureNotificationPayload,
+  ): Promise<void> {
+    if (!this.sesModule) {
+      this.logger.warn(
+        '@aws-sdk/client-ses not installed, skipping email notification',
+      );
+      return;
+    }
+
+    try {
+      const ses = this.sesModule;
+      const region = this.config.aws.region;
+      const client = new ses.SESClient({ region });
+
+      const subject = `[Fabric] Critical: ${payload.type} - ${payload.projectId}/${payload.employeeId}`;
+      const body = [
+        `Critical failure in deployment ${payload.projectId}/${payload.employeeId} (${payload.env})`,
+        '',
+        `Type: ${payload.type}`,
+        `Message: ${payload.message}`,
+        payload.retryCount != null ? `Retry count: ${payload.retryCount}` : '',
+        '',
+        `Project: ${payload.projectId}`,
+        `Employee: ${payload.employeeId}`,
+        `Environment: ${payload.env}`,
+      ]
+        .filter(Boolean)
+        .join('\n');
+
+      const command = new ses.SendEmailCommand({
+        Source: fromEmail,
+        Destination: { ToAddresses: toEmails },
+        Message: {
+          Subject: { Data: subject, Charset: 'UTF-8' },
+          Body: { Text: { Data: body, Charset: 'UTF-8' } },
+        },
+      });
+
+      await client.send(command);
+      this.logger.log(`Sent failure notification to ${toEmails.join(', ')}`);
+    } catch (err) {
+      this.logger.error(`Failed to send failure email: ${err}`);
+    }
+  }
+}

package/apps/fabric/src/project-source/errors/project-source.errors.ts

@@ -0,0 +1,8 @@
+import { HttpStatus } from '@nestjs/common';
+import { DomainError } from '@app/common';
+
+export class SourceResolutionError extends DomainError {
+  constructor(message: string) {
+    super(message, HttpStatus.BAD_REQUEST);
+  }
+}

package/apps/fabric/src/project-source/project-source.module.ts

@@ -0,0 +1,8 @@
+import { Module } from '@nestjs/common';
+import { ProjectSourceService } from './project-source.service';
+
+@Module({
+  providers: [ProjectSourceService],
+  exports: [ProjectSourceService],
+})
+export class ProjectSourceModule {}

package/apps/fabric/src/project-source/project-source.service.ts

@@ -0,0 +1,75 @@
+import { Inject, Injectable, Logger } from '@nestjs/common';
+import type { ConfigType } from '@nestjs/config';
+import { existsSync, statSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { simpleGit } from 'simple-git';
+import fabricConfig from '../config/configuration';
+import type { ProjectSourceConfig } from './project-source.types';
+import { SourceResolutionError } from './errors/project-source.errors';
+
+const GIT_TIMEOUT_MS = 60_000;
+
+@Injectable()
+export class ProjectSourceService {
+  private readonly logger = new Logger(ProjectSourceService.name);
+  private readonly workspacePath: string;
+
+  constructor(
+    @Inject(fabricConfig.KEY)
+    private readonly config: ConfigType<typeof fabricConfig>,
+  ) {
+    this.workspacePath = resolve(this.config.workspacePath);
+  }
+
+  async resolve(source: ProjectSourceConfig): Promise<string> {
+    if (source.type === 'github') {
+      return this.cloneGithub(source);
+    }
+    return this.resolveLocal(source);
+  }
+
+  private async cloneGithub(source: {
+    org: string;
+    repo: string;
+    branch?: string;
+  }): Promise<string> {
+    const url = `https://github.com/${source.org}/${source.repo}.git`;
+    const dirName = `${source.org}-${source.repo}-${Date.now()}`;
+    const repoDir = resolve(this.workspacePath, 'repos', dirName);
+
+    const git = simpleGit({ timeout: { block: GIT_TIMEOUT_MS } });
+    const cloneArgs = [
+      '--depth',
+      '1',
+      ...(source.branch ? ['--branch', source.branch] : []),
+    ];
+
+    try {
+      await git.clone(url, repoDir, cloneArgs);
+      this.logger.log(
+        `Cloned ${source.org}/${source.repo}${source.branch ? `@${source.branch}` : ''} → ${repoDir}`,
+      );
+      return repoDir;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      throw new SourceResolutionError(`Failed to clone ${url}: ${message}`);
+    }
+  }
+
+  private resolveLocal(source: { path: string }): string {
+    const absolutePath = resolve(source.path);
+
+    if (!existsSync(absolutePath)) {
+      throw new SourceResolutionError(`Path does not exist: ${absolutePath}`);
+    }
+
+    if (!statSync(absolutePath).isDirectory()) {
+      throw new SourceResolutionError(
+        `Path is not a directory: ${absolutePath}`,
+      );
+    }
+
+    this.logger.log(`Resolved local source: ${absolutePath}`);
+    return absolutePath;
+  }
+}

package/apps/fabric/src/project-source/project-source.types.ts

@@ -0,0 +1,5 @@
+export type ProjectSourceType = 'github' | 'local';
+
+export type ProjectSourceConfig =
+  | { type: 'github'; org: string; repo: string; branch?: string }
+  | { type: 'local'; path: string };

package/apps/fabric/src/projects/dto/project.dto.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+import { createZodDto } from 'nestjs-zod';
+
+export const CreateProjectSchema = z.object({
+  id: z.string().min(1).max(100).optional(),
+  name: z.string().min(1),
+  environmentId: z.string().min(1),
+});
+
+export class CreateProjectDto extends createZodDto(CreateProjectSchema) {}
+
+export const UpdateProjectSchema = z.object({
+  name: z.string().min(1).optional(),
+  environmentId: z.string().min(1).optional(),
+});
+
+export class UpdateProjectDto extends createZodDto(UpdateProjectSchema) {}
+
+export const DeployAllSchema = z.object({
+  /** Optional Fabric environment id; defaults to the project's `environmentId`. */
+  env: z.string().min(1).optional(),
+  track: z.enum(['draft', 'live']).default('draft'),
+});
+
+export class DeployAllDto extends createZodDto(DeployAllSchema) {}

package/apps/fabric/src/projects/errors/project.errors.ts

@@ -0,0 +1,17 @@
+import { HttpStatus } from '@nestjs/common';
+import { DomainError } from '@app/common';
+
+export class ProjectNotFoundError extends DomainError {
+  constructor(id: string) {
+    super(`Project ${id} not found`, HttpStatus.NOT_FOUND);
+  }
+}
+
+export class ProjectHasRunningEmployeesError extends DomainError {
+  constructor(id: string) {
+    super(
+      `Cannot delete project ${id}: employees are still running`,
+      HttpStatus.CONFLICT,
+    );
+  }
+}

package/apps/fabric/src/projects/projects-data.service.ts

@@ -0,0 +1,60 @@
+import { Injectable, Inject, Optional } from '@nestjs/common';
+import { REGISTRY_PROVIDER, RegistryProvider } from '@app/project-provider';
+import { ProjectsStore } from './projects.store';
+import type { Project } from './projects.types';
+
+/**
+ * Provides project data from either the shared registry (monolith) or
+ * Fabric's store (standalone). Used by ProjectsService and EmployeesService
+ * to avoid circular dependencies.
+ */
+@Injectable()
+export class ProjectsDataService {
+  constructor(
+    private readonly store: ProjectsStore,
+    @Optional()
+    @Inject(REGISTRY_PROVIDER)
+    private readonly registry: RegistryProvider | null,
+  ) {}
+
+  private get useRegistry(): boolean {
+    return this.registry != null;
+  }
+
+  async get(id: string): Promise<Project | null> {
+    if (this.useRegistry) {
+      const p = await this.registry!.getProject(id);
+      if (!p) return null;
+      const now = new Date().toISOString();
+      return {
+        id: p.id,
+        userId: null,
+        name: p.name ?? p.id,
+        environmentId: p.environmentId ?? '',
+        dbName: p.dbName ?? null,
+        createdAt: now,
+        updatedAt: now,
+      };
+    }
+    return this.store.get(id) ?? null;
+  }
+
+  async list(): Promise<Project[]> {
+    if (this.useRegistry) {
+      const projects = await this.registry!.listProjects();
+      const now = new Date().toISOString();
+      return projects
+        .filter((p) => p.environmentId)
+        .map((p) => ({
+          id: p.id,
+          userId: null,
+          name: p.name ?? p.id,
+          environmentId: p.environmentId!,
+          dbName: p.dbName ?? null,
+          createdAt: now,
+          updatedAt: now,
+        }));
+    }
+    return this.store.list();
+  }
+}

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

@@ -0,0 +1,92 @@
+import {
+  Controller,
+  Get,
+  Post,
+  Patch,
+  Delete,
+  Param,
+  Body,
+  HttpCode,
+  HttpStatus,
+  Inject,
+  forwardRef,
+} from '@nestjs/common';
+import { ProjectsService } from './projects.service';
+import { EmployeesService } from '../employees/employees.service';
+import {
+  CreateProjectDto,
+  DeployAllDto,
+  UpdateProjectDto,
+} from './dto/project.dto';
+import { CurrentUser } from '../auth/current-user.decorator';
+
+@Controller('projects')
+export class ProjectsController {
+  constructor(
+    private readonly projectsService: ProjectsService,
+    @Inject(forwardRef(() => EmployeesService))
+    private readonly employeesService: EmployeesService,
+  ) {}
+
+  @Post()
+  @HttpCode(HttpStatus.CREATED)
+  create(@Body() dto: CreateProjectDto, @CurrentUser('userId') userId: string) {
+    return this.projectsService.create({
+      userId,
+      id: dto.id,
+      name: dto.name,
+      environmentId: dto.environmentId,
+    });
+  }
+
+  @Get()
+  async list() {
+    const data = await this.projectsService.list();
+    return { data };
+  }
+
+  @Get(':projectId/employees')
+  listEmployees(@Param('projectId') projectId: string) {
+    return { data: this.employeesService.getBulkStatus(projectId) };
+  }
+
+  @Post(':projectId/deploy-all')
+  @HttpCode(HttpStatus.ACCEPTED)
+  deployAll(
+    @Param('projectId') projectId: string,
+    @Body() dto: DeployAllDto,
+    @CurrentUser('userId') userId: string,
+  ) {
+    return this.projectsService.deployAll(
+      projectId,
+      dto.track,
+      dto.env,
+      userId,
+    );
+  }
+
+  @Post(':projectId/undeploy-all')
+  @HttpCode(HttpStatus.OK)
+  undeployAll(
+    @Param('projectId') projectId: string,
+    @Body() dto: DeployAllDto,
+  ) {
+    return this.projectsService.undeployAll(projectId, dto.track, dto.env);
+  }
+
+  @Get(':id')
+  async get(@Param('id') id: string) {
+    return this.projectsService.get(id);
+  }
+
+  @Patch(':id')
+  async update(@Param('id') id: string, @Body() dto: UpdateProjectDto) {
+    return this.projectsService.update(id, dto);
+  }
+
+  @Delete(':id')
+  @HttpCode(HttpStatus.NO_CONTENT)
+  async delete(@Param('id') id: string): Promise<void> {
+    await this.projectsService.delete(id);
+  }
+}

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

@@ -0,0 +1,20 @@
+import { Module, forwardRef } from '@nestjs/common';
+import { ProjectsController } from './projects.controller';
+import { ProjectsService } from './projects.service';
+import { ProjectsDataService } from './projects-data.service';
+import { ProjectsStore } from './projects.store';
+import { EnvironmentsModule } from '../environments/environments.module';
+import { ProvisionersModule } from '../provisioners/provisioners.module';
+import { EmployeesModule } from '../employees/employees.module';
+
+@Module({
+  imports: [
+    EnvironmentsModule,
+    ProvisionersModule,
+    forwardRef(() => EmployeesModule),
+  ],
+  controllers: [ProjectsController],
+  providers: [ProjectsService, ProjectsDataService, ProjectsStore],
+  exports: [ProjectsService, ProjectsDataService, ProjectsStore],
+})
+export class ProjectsModule {}