@agentlang/agentmanager 0.0.3

package/apps/fabric/src/provisioners/cognito-provisioner.service.ts

@@ -0,0 +1,168 @@
+import { Injectable, Inject, Logger } from '@nestjs/common';
+import type { ConfigType } from '@nestjs/config';
+import { randomBytes } from 'node:crypto';
+import fabricConfig from '../config/configuration';
+
+export const COGNITO_MODULE = Symbol('COGNITO_MODULE');
+
+interface CognitoClient {
+  send: (command: unknown) => Promise<Record<string, unknown>>;
+}
+
+interface CognitoModule {
+  CognitoIdentityProviderClient: new (opts: {
+    region: string;
+  }) => CognitoClient;
+  CreateUserPoolCommand: new (params: Record<string, unknown>) => unknown;
+  CreateUserPoolClientCommand: new (params: Record<string, unknown>) => unknown;
+  AdminCreateUserCommand: new (params: Record<string, unknown>) => unknown;
+  AdminSetUserPasswordCommand: new (params: Record<string, unknown>) => unknown;
+  DeleteUserPoolCommand: new (params: Record<string, unknown>) => unknown;
+}
+
+export interface CognitoProvisionResult {
+  userPoolId: string;
+  clientId: string;
+  region: string;
+  defaultUsername: string;
+  defaultEmail: string;
+  defaultPassword: string;
+}
+
+function generatePassword(): string {
+  const chars =
+    'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%';
+  const bytes = randomBytes(24);
+  let s = '';
+  for (let i = 0; i < 16; i++) {
+    s += chars[bytes[i] % chars.length];
+  }
+  return s + '1A!';
+}
+
+@Injectable()
+export class CognitoProvisionerService {
+  private readonly logger = new Logger(CognitoProvisionerService.name);
+
+  constructor(
+    @Inject(fabricConfig.KEY)
+    private readonly config: ConfigType<typeof fabricConfig>,
+    @Inject(COGNITO_MODULE)
+    private readonly cognitoModule: CognitoModule | null,
+  ) {}
+
+  async provision(
+    deploymentId: string,
+    defaultUsername: string,
+    defaultEmail: string,
+  ): Promise<CognitoProvisionResult> {
+    if (!this.cognitoModule) {
+      throw new Error(
+        '@aws-sdk/client-cognito-identity-provider not installed',
+      );
+    }
+
+    const cognito = this.cognitoModule;
+    const region = this.config.aws.region;
+    const client = new cognito.CognitoIdentityProviderClient({ region });
+
+    const poolName = `deploy-${deploymentId.replace(/-/g, '_').slice(0, 50)}`;
+
+    const poolRes = (await client.send(
+      new cognito.CreateUserPoolCommand({
+        PoolName: poolName,
+        AutoVerifiedAttributes: ['email'],
+        UsernameAttributes: ['email'],
+        Schema: [
+          { Name: 'email', AttributeDataType: 'String', Required: true },
+        ],
+        Policies: {
+          PasswordPolicy: {
+            MinimumLength: 8,
+            RequireUppercase: true,
+            RequireLowercase: true,
+            RequireNumbers: true,
+            RequireSymbols: false,
+          },
+        },
+      }),
+    )) as { UserPool?: { Id?: string } };
+
+    const userPoolId = poolRes.UserPool?.Id;
+    if (!userPoolId) throw new Error('Failed to create user pool');
+
+    const clientRes = (await client.send(
+      new cognito.CreateUserPoolClientCommand({
+        UserPoolId: userPoolId,
+        ClientName: `${poolName}-client`,
+        GenerateSecret: false,
+        ExplicitAuthFlows: ['ALLOW_USER_PASSWORD_AUTH', 'ALLOW_USER_SRP_AUTH'],
+      }),
+    )) as { UserPoolClient?: { ClientId?: string } };
+
+    const clientId = clientRes.UserPoolClient?.ClientId;
+    if (!clientId) throw new Error('Failed to create user pool client');
+
+    const defaultPassword = generatePassword();
+
+    const emailForUsername =
+      (defaultEmail?.includes('@') ? defaultEmail : null) ??
+      (defaultUsername?.includes('@') ? defaultUsername : null);
+
+    if (!emailForUsername) {
+      throw new Error('Auth requires an email for the default user.');
+    }
+
+    await client.send(
+      new cognito.AdminCreateUserCommand({
+        UserPoolId: userPoolId,
+        Username: emailForUsername,
+        TemporaryPassword: defaultPassword,
+        MessageAction: 'SUPPRESS',
+        UserAttributes: [
+          { Name: 'email', Value: emailForUsername },
+          { Name: 'email_verified', Value: 'true' },
+        ],
+      }),
+    );
+
+    await client.send(
+      new cognito.AdminSetUserPasswordCommand({
+        UserPoolId: userPoolId,
+        Username: emailForUsername,
+        Password: defaultPassword,
+        Permanent: true,
+      }),
+    );
+
+    this.logger.log(
+      `Provisioned Cognito pool ${userPoolId} for deployment ${deploymentId}`,
+    );
+
+    return {
+      userPoolId,
+      clientId,
+      region,
+      defaultUsername: emailForUsername,
+      defaultEmail: emailForUsername,
+      defaultPassword,
+    };
+  }
+
+  async deletePool(userPoolId: string): Promise<void> {
+    if (!this.cognitoModule) {
+      this.logger.warn(
+        '@aws-sdk/client-cognito-identity-provider not installed, cannot delete pool',
+      );
+      return;
+    }
+
+    const cognito = this.cognitoModule;
+    const region = this.config.aws.region;
+    const client = new cognito.CognitoIdentityProviderClient({ region });
+    await client.send(
+      new cognito.DeleteUserPoolCommand({ UserPoolId: userPoolId }),
+    );
+    this.logger.log(`Deleted Cognito pool ${userPoolId}`);
+  }
+}

package/apps/fabric/src/provisioners/postgres-provisioner.service.ts

@@ -0,0 +1,124 @@
+import { Injectable, Inject, Logger } from '@nestjs/common';
+import { DatabaseConnectionHolder } from '@app/common';
+
+export const PG_MODULE = Symbol('PG_MODULE');
+
+export interface PostgresCredentials {
+  dbname: string;
+  host: string;
+  port: number;
+  username: string;
+  password: string;
+}
+
+interface PgClient {
+  connect: () => Promise<void>;
+  query: (sql: string) => Promise<unknown>;
+  end: () => Promise<void>;
+}
+
+type PgClientConstructor = new (opts: Record<string, unknown>) => PgClient;
+
+interface PgModule {
+  Client?: PgClientConstructor;
+  default?: { Client?: PgClientConstructor };
+}
+
+@Injectable()
+export class PostgresProvisionerService {
+  private readonly logger = new Logger(PostgresProvisionerService.name);
+  private pgClientClass: PgClientConstructor | null = null;
+
+  constructor(
+    private readonly connectionHolder: DatabaseConnectionHolder,
+    @Inject(PG_MODULE) private readonly pgModule: PgModule | null,
+  ) {
+    if (this.pgModule) {
+      this.pgClientClass =
+        this.pgModule.Client ?? this.pgModule.default?.Client ?? null;
+    }
+  }
+
+  private getConnectionParams() {
+    const params = this.connectionHolder.get();
+    return {
+      host: params.host,
+      port: params.port,
+      username: params.user,
+      password: params.password,
+    };
+  }
+
+  private async withAdminClient<T>(
+    fn: (client: PgClient) => Promise<T>,
+  ): Promise<T> {
+    if (!this.pgClientClass) {
+      throw new Error('pg package not installed');
+    }
+    const { host, port, username, password } = this.getConnectionParams();
+    const client = new this.pgClientClass({
+      host,
+      port,
+      user: username,
+      password,
+      database: 'postgres',
+    });
+
+    try {
+      await client.connect();
+      return await fn(client);
+    } finally {
+      await client.end();
+    }
+  }
+
+  async createDatabase(identifier: string): Promise<PostgresCredentials> {
+    const { host, port, username, password } = this.getConnectionParams();
+    const dbname = `deploy_${identifier.replace(/-/g, '_')}`;
+
+    await this.withAdminClient(async (client) => {
+      await client.query(`CREATE DATABASE "${dbname}"`);
+    });
+
+    this.logger.log(`Created database: ${dbname}`);
+    return { dbname, host, port, username, password };
+  }
+
+  async createNewDatabase(identifier: string): Promise<PostgresCredentials> {
+    const { host, port, username, password } = this.getConnectionParams();
+    const base = identifier.replace(/-/g, '_');
+    const dbname = `deploy_${base}_${Date.now()}`;
+
+    await this.withAdminClient(async (client) => {
+      await client.query(`CREATE DATABASE "${dbname}"`);
+    });
+
+    this.logger.log(`Created new database: ${dbname}`);
+    return { dbname, host, port, username, password };
+  }
+
+  async createProjectDatabase(projectId: string): Promise<PostgresCredentials> {
+    const { host, port, username, password } = this.getConnectionParams();
+    const dbname = `project_${projectId.replace(/-/g, '_')}`;
+
+    await this.withAdminClient(async (client) => {
+      await client.query(`CREATE DATABASE "${dbname}"`);
+    });
+
+    this.logger.log(`Created project database: ${dbname}`);
+    return { dbname, host, port, username, password };
+  }
+
+  getCredentialsForExistingDb(dbname: string): PostgresCredentials {
+    const { host, port, username, password } = this.getConnectionParams();
+    return { dbname, host, port, username, password };
+  }
+
+  async dropDatabase(dbname: string): Promise<void> {
+    await this.withAdminClient(async (client) => {
+      await client.query(`DROP DATABASE IF EXISTS "${dbname}"`);
+    });
+
+    this.logger.log(`Dropped database: ${dbname}`);
+  }
+}

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

@@ -0,0 +1,40 @@
+import { Module } from '@nestjs/common';
+import {
+  PostgresProvisionerService,
+  PG_MODULE,
+} from './postgres-provisioner.service';
+import {
+  CognitoProvisionerService,
+  COGNITO_MODULE,
+} from './cognito-provisioner.service';
+
+@Module({
+  providers: [
+    PostgresProvisionerService,
+    CognitoProvisionerService,
+    {
+      provide: PG_MODULE,
+      useFactory: async () => {
+        try {
+          const name = 'pg';
+          return (await import(name)) as unknown;
+        } catch {
+          return null;
+        }
+      },
+    },
+    {
+      provide: COGNITO_MODULE,
+      useFactory: async () => {
+        try {
+          const name = '@aws-sdk/client-cognito-identity-provider';
+          return (await import(name)) as unknown;
+        } catch {
+          return null;
+        }
+      },
+    },
+  ],
+  exports: [PostgresProvisionerService, CognitoProvisionerService],
+})
+export class ProvisionersModule {}

package/apps/fabric/src/user-config/user-config.module.ts

@@ -0,0 +1,9 @@
+import { Module } from '@nestjs/common';
+import { UserConfigService } from './user-config.service';
+import { UserConfigStore } from './user-config.store';
+
+@Module({
+  providers: [UserConfigService, UserConfigStore],
+  exports: [UserConfigService],
+})
+export class UserConfigModule {}

package/apps/fabric/src/user-config/user-config.service.ts

@@ -0,0 +1,54 @@
+import { Injectable } from '@nestjs/common';
+import { UserConfigStore } from './user-config.store';
+import type { UserConfig } from './user-config.types';
+
+@Injectable()
+export class UserConfigService {
+  constructor(private readonly store: UserConfigStore) {}
+
+  getConfig(userId: string): UserConfig {
+    return this.store.getOrDefault(userId);
+  }
+
+  getHealthcheckMaxRetries(userId: string): number {
+    return this.store.getOrDefault(userId).healthcheckMaxRetries;
+  }
+
+  updateConfig(
+    userId: string,
+    updates: {
+      healthcheckMaxRetries?: number;
+      notificationFromEmail?: string | null;
+      notificationToEmails?: string[];
+    },
+  ): UserConfig {
+    const existing = this.store.getOrDefault(userId);
+    const updated: UserConfig = {
+      ...existing,
+      ...(updates.healthcheckMaxRetries !== undefined && {
+        healthcheckMaxRetries: updates.healthcheckMaxRetries,
+      }),
+      ...(updates.notificationFromEmail !== undefined && {
+        notificationFromEmail: updates.notificationFromEmail,
+      }),
+      ...(updates.notificationToEmails !== undefined && {
+        notificationToEmails: updates.notificationToEmails,
+      }),
+      updatedAt: new Date().toISOString(),
+    };
+
+    this.store.set(updated);
+    return updated;
+  }
+
+  getNotificationConfig(userId: string): {
+    fromEmail: string | null;
+    toEmails: string[];
+  } {
+    const config = this.store.getOrDefault(userId);
+    return {
+      fromEmail: config.notificationFromEmail,
+      toEmails: config.notificationToEmails,
+    };
+  }
+}

package/apps/fabric/src/user-config/user-config.store.ts

@@ -0,0 +1,120 @@
+import {
+  Injectable,
+  OnModuleInit,
+  OnModuleDestroy,
+  Logger,
+} from '@nestjs/common';
+import type { Repository } from 'typeorm';
+import { FileStoreFactory, FileStore, DataSourceService } from '@app/common';
+import { UserConfigEntity } from '../database/entities';
+import type { UserConfig } from './user-config.types';
+import { DEFAULT_HEALTHCHECK_MAX_RETRIES } from './user-config.types';
+
+interface PersistedData {
+  configs: Record<string, UserConfig>;
+}
+
+@Injectable()
+export class UserConfigStore implements OnModuleInit, OnModuleDestroy {
+  private readonly logger = new Logger(UserConfigStore.name);
+  private readonly configs = new Map<string, UserConfig>();
+  private readonly fileStore: FileStore<PersistedData>;
+  private repo: Repository<UserConfigEntity> | null = null;
+
+  constructor(
+    fileStoreFactory: FileStoreFactory,
+    private readonly dataSourceService: DataSourceService,
+  ) {
+    this.fileStore =
+      fileStoreFactory.create<PersistedData>('user-configs.json');
+  }
+
+  async onModuleInit() {
+    this.repo = this.dataSourceService.getRepository(UserConfigEntity);
+
+    if (this.repo) {
+      const rows = await this.repo.find();
+      for (const row of rows) {
+        this.configs.set(row.userId, this.entityToConfig(row));
+      }
+      this.logger.log(`Loaded ${this.configs.size} user configs from database`);
+    } else {
+      const data = await this.fileStore.load();
+      if (data?.configs) {
+        for (const [key, config] of Object.entries(data.configs)) {
+          this.configs.set(key, config);
+        }
+        this.logger.log(`Loaded ${this.configs.size} user configs from disk`);
+      }
+    }
+  }
+
+  private entityToConfig(entity: UserConfigEntity): UserConfig {
+    return {
+      userId: entity.userId,
+      healthcheckMaxRetries: entity.healthcheckMaxRetries,
+      notificationFromEmail: entity.notificationFromEmail,
+      notificationToEmails: entity.notificationToEmails,
+      createdAt: entity.createdAt,
+      updatedAt: entity.updatedAt,
+    };
+  }
+
+  private configToEntity(config: UserConfig): UserConfigEntity {
+    const entity = new UserConfigEntity();
+    entity.userId = config.userId;
+    entity.healthcheckMaxRetries = config.healthcheckMaxRetries;
+    entity.notificationFromEmail = config.notificationFromEmail;
+    entity.notificationToEmails = config.notificationToEmails;
+    entity.createdAt = config.createdAt;
+    entity.updatedAt = config.updatedAt;
+    return entity;
+  }
+
+  private persist(config?: UserConfig): void {
+    if (this.repo && config) {
+      this.repo
+        .save(this.configToEntity(config))
+        .catch((err) =>
+          this.logger.error(`Failed to persist user config: ${err}`),
+        );
+    } else if (!this.repo) {
+      const configs: Record<string, UserConfig> = {};
+      for (const [key, c] of this.configs) {
+        configs[key] = c;
+      }
+      this.fileStore.save({ configs });
+    }
+  }
+
+  get(userId: string): UserConfig | undefined {
+    return this.configs.get(userId);
+  }
+
+  getOrDefault(userId: string): UserConfig {
+    const existing = this.configs.get(userId);
+    if (existing) return existing;
+    return {
+      userId,
+      healthcheckMaxRetries: DEFAULT_HEALTHCHECK_MAX_RETRIES,
+      notificationFromEmail: null,
+      notificationToEmails: [],
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+    };
+  }
+
+  set(config: UserConfig): void {
+    this.configs.set(config.userId, config);
+    this.persist(config);
+  }
+
+  async onModuleDestroy() {
+    if (!this.repo) {
+      await this.fileStore.flush();
+    }
+    this.logger.log(
+      `UserConfigStore shutting down with ${this.configs.size} configs`,
+    );
+  }
+}

package/apps/fabric/src/user-config/user-config.types.ts

@@ -0,0 +1,11 @@
+export interface UserConfig {
+  userId: string;
+  healthcheckMaxRetries: number;
+  notificationFromEmail: string | null;
+  notificationToEmails: string[];
+  createdAt: string;
+  updatedAt: string;
+}
+
+export const DEFAULT_HEALTHCHECK_MAX_RETRIES = 3;
+export const DEFAULT_USER_ID = '__anonymous__';

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

@@ -0,0 +1,24 @@
+import { Controller, Get, Param } from '@nestjs/common';
+import { VersionsService } from './versions.service';
+
+@Controller('projects/:projectId/employees/:employeeId/versions')
+export class VersionsController {
+  constructor(private readonly versionsService: VersionsService) {}
+
+  @Get()
+  list(
+    @Param('projectId') projectId: string,
+    @Param('employeeId') employeeId: string,
+  ) {
+    return { data: this.versionsService.list(projectId, employeeId) };
+  }
+
+  @Get(':versionId')
+  get(
+    @Param('projectId') projectId: string,
+    @Param('employeeId') employeeId: string,
+    @Param('versionId') versionId: string,
+  ) {
+    return this.versionsService.get(projectId, employeeId, versionId);
+  }
+}

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

@@ -0,0 +1,11 @@
+import { Module } from '@nestjs/common';
+import { VersionsController } from './versions.controller';
+import { VersionsService } from './versions.service';
+import { VersionsStore } from './versions.store';
+
+@Module({
+  controllers: [VersionsController],
+  providers: [VersionsService, VersionsStore],
+  exports: [VersionsService],
+})
+export class VersionsModule {}

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

@@ -0,0 +1,65 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { VersionsStore } from './versions.store';
+import type { VersionSnapshot, VersionSummary } from './versions.types';
+import { VersionNotFoundError } from '../employees/errors/employee-deployment.errors';
+
+@Injectable()
+export class VersionsService {
+  private readonly logger = new Logger(VersionsService.name);
+
+  constructor(private readonly store: VersionsStore) {}
+
+  create(projectId: string, employeeId: string): VersionSnapshot {
+    const versionId = this.store.generateId();
+    const now = new Date().toISOString();
+
+    // TODO: fetch the current draft state from agentmanager and store it
+    const snapshot: VersionSnapshot = {
+      versionId,
+      projectId,
+      employeeId,
+      createdAt: now,
+      snapshot: {},
+    };
+
+    this.store.append(snapshot);
+    this.logger.log(
+      `Created version ${versionId} for ${projectId}/${employeeId}`,
+    );
+
+    return snapshot;
+  }
+
+  list(projectId: string, employeeId: string): VersionSummary[] {
+    return this.store.list(projectId, employeeId).map((v) => ({
+      versionId: v.versionId,
+      createdAt: v.createdAt,
+    }));
+  }
+
+  get(
+    projectId: string,
+    employeeId: string,
+    versionId: string,
+  ): VersionSnapshot {
+    const version = this.store.get(projectId, employeeId, versionId);
+    if (!version) {
+      throw new VersionNotFoundError(projectId, employeeId, versionId);
+    }
+    return version;
+  }
+
+  getLatest(
+    projectId: string,
+    employeeId: string,
+  ): VersionSnapshot | undefined {
+    return this.store.getLatest(projectId, employeeId);
+  }
+
+  getPrevious(
+    projectId: string,
+    employeeId: string,
+  ): VersionSnapshot | undefined {
+    return this.store.getPrevious(projectId, employeeId);
+  }
+}