@agentlang/agentmanager 0.0.3

package/apps/fabric/src/config/configuration.ts

@@ -0,0 +1,266 @@
+import { registerAs } from '@nestjs/config';
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { Logger } from '@nestjs/common';
+import { z } from 'zod';
+
+export interface AppConfiguration {
+  port: number;
+  workspacePath: string;
+  /** AgentLang registry root (project copies live at registryPath/projectId/employeeId). */
+  registryPath: string;
+  snapshotsPath: string;
+  dataPath: string;
+  provider: 'pm2' | 'docker' | 'eks';
+  healthcheckIntervalMs: number;
+  /** Min delay between AI investigations for the same deployment after a failed POST probe. */
+  probeAiCooldownMs: number;
+  healthcheckCpuThreshold: number;
+  healthcheckMemoryThreshold: number;
+  embeddedDbPort: number;
+  embeddedDbName: string;
+  agentmanager?: {
+    baseUrl: string;
+  };
+  database: {
+    host: string | null;
+    port: number;
+    user: string;
+    password: string;
+  };
+  aws: {
+    region: string;
+    accessKeyId: string | null;
+    secretAccessKey: string | null;
+  };
+  cognito: {
+    userPoolId: string | null;
+    clientId: string | null;
+    clientSecret: string | null;
+  };
+  openai: { apiKey: string | null; model: string };
+  anthropic: { apiKey: string | null; model: string };
+  /** Which LLM to use for HTTP probe failure investigation (`auto` = Anthropic if key set, else OpenAI). */
+  aiProvider: 'auto' | 'anthropic' | 'openai';
+  ses: { fromEmail: string | null; escalationToEmail: string | null };
+  docker: { baseImage: string };
+  eks: { namespace: string };
+  cors: { origins: string[] };
+}
+
+const configSchema = z.object({
+  port: z.number().int().positive(),
+  workspacePath: z.string().min(1),
+  registryPath: z.string().min(1),
+  snapshotsPath: z.string().min(1),
+  dataPath: z.string().min(1),
+  provider: z.enum(['pm2', 'docker', 'eks']),
+  healthcheckIntervalMs: z.number().int().positive(),
+  probeAiCooldownMs: z.number().int().nonnegative(),
+  healthcheckCpuThreshold: z.number().min(0).max(1),
+  healthcheckMemoryThreshold: z.number().min(0).max(1),
+  embeddedDbPort: z.number().int().positive(),
+  embeddedDbName: z.string().min(1),
+  agentmanager: z.object({ baseUrl: z.string() }).optional(),
+  database: z.object({
+    host: z.string().nullable(),
+    port: z.number().int().positive(),
+    user: z.string(),
+    password: z.string(),
+  }),
+  aws: z.object({
+    region: z.string(),
+    accessKeyId: z.string().nullable(),
+    secretAccessKey: z.string().nullable(),
+  }),
+  cognito: z.object({
+    userPoolId: z.string().nullable(),
+    clientId: z.string().nullable(),
+    clientSecret: z.string().nullable(),
+  }),
+  openai: z.object({
+    apiKey: z.string().nullable(),
+    model: z.string(),
+  }),
+  anthropic: z.object({
+    apiKey: z.string().nullable(),
+    model: z.string(),
+  }),
+  aiProvider: z.enum(['auto', 'anthropic', 'openai']),
+  ses: z.object({
+    fromEmail: z.string().nullable(),
+    escalationToEmail: z.string().nullable(),
+  }),
+  docker: z.object({ baseImage: z.string() }),
+  eks: z.object({ namespace: z.string() }),
+  cors: z.object({ origins: z.array(z.string()) }),
+});
+
+export default registerAs('fabric', (): AppConfiguration => {
+  const logger = new Logger('FabricConfig');
+  const configPath = resolve(process.env.CONFIG_PATH ?? './config.json');
+  let parsed: Record<string, unknown> = {};
+
+  try {
+    const raw = readFileSync(configPath, 'utf-8');
+    parsed = JSON.parse(raw) as Record<string, unknown>;
+  } catch {
+    // Fall back to defaults / env vars
+  }
+
+  const isProduction = process.env.NODE_ENV === 'production';
+  const dbPassword =
+    (parsed.database as Record<string, unknown>)?.password ??
+    process.env.DB_PASSWORD ??
+    undefined;
+
+  if (isProduction && !dbPassword) {
+    logger.warn(
+      'DB_PASSWORD not set in production — using default credentials is insecure',
+    );
+  }
+
+  const config = {
+    port: parsed.port ?? parseInt(process.env.PORT ?? '3003', 10),
+    workspacePath:
+      parsed.workspacePath ?? process.env.WORKSPACE_PATH ?? './.deployments',
+    registryPath:
+      parsed.registryPath ?? process.env.REGISTRY_PATH ?? './registry',
+    snapshotsPath:
+      parsed.snapshotsPath ?? process.env.SNAPSHOTS_PATH ?? './snapshots',
+    dataPath: parsed.dataPath ?? process.env.DATA_PATH ?? './data',
+    provider: parsed.provider ?? process.env.FABRIC_PROVIDER ?? 'pm2',
+    healthcheckIntervalMs:
+      parsed.healthcheckIntervalMs ??
+      (Number(process.env.HEALTHCHECK_INTERVAL_MS) || 15_000),
+    probeAiCooldownMs:
+      parsed.probeAiCooldownMs !== undefined
+        ? Number(parsed.probeAiCooldownMs)
+        : Number(process.env.FABRIC_PROBE_AI_COOLDOWN_MS) || 180_000,
+    healthcheckCpuThreshold:
+      parsed.healthcheckCpuThreshold ??
+      (Number(process.env.HEALTHCHECK_CPU_THRESHOLD) || 0.9),
+    healthcheckMemoryThreshold:
+      parsed.healthcheckMemoryThreshold ??
+      (Number(process.env.HEALTHCHECK_MEMORY_THRESHOLD) || 0.9),
+    embeddedDbPort:
+      parsed.embeddedDbPort ?? (Number(process.env.EMBEDDED_DB_PORT) || 5433),
+    embeddedDbName:
+      parsed.embeddedDbName ?? process.env.EMBEDDED_DB_NAME ?? 'fabric',
+    agentmanager: parsed.agentmanager ?? undefined,
+    database: {
+      host:
+        (parsed.database as Record<string, unknown>)?.host ??
+        process.env.DB_HOST ??
+        null,
+      port:
+        (parsed.database as Record<string, unknown>)?.port ??
+        (Number(process.env.DB_PORT) || 5432),
+      user:
+        (parsed.database as Record<string, unknown>)?.user ??
+        process.env.DB_USER ??
+        'postgres',
+      password:
+        (parsed.database as Record<string, unknown>)?.password ??
+        process.env.DB_PASSWORD ??
+        'postgres',
+    },
+    aws: {
+      region:
+        (parsed.aws as Record<string, unknown>)?.region ??
+        process.env.AWS_REGION ??
+        process.env.COGNITO_REGION ??
+        process.env.AWS_DEFAULT_REGION ??
+        'us-east-1',
+      accessKeyId:
+        (parsed.aws as Record<string, unknown>)?.accessKeyId ??
+        process.env.AWS_ACCESS_KEY_ID ??
+        process.env.AWS_ACCESS_KEY ??
+        null,
+      secretAccessKey:
+        (parsed.aws as Record<string, unknown>)?.secretAccessKey ??
+        process.env.AWS_SECRET_ACCESS_KEY ??
+        process.env.AWS_SECRET_KEY ??
+        null,
+    },
+    cognito: {
+      userPoolId:
+        (parsed.cognito as Record<string, unknown>)?.userPoolId ??
+        process.env.COGNITO_USER_POOL_ID ??
+        null,
+      clientId:
+        (parsed.cognito as Record<string, unknown>)?.clientId ??
+        process.env.COGNITO_CLIENT_ID ??
+        null,
+      clientSecret:
+        (parsed.cognito as Record<string, unknown>)?.clientSecret ??
+        process.env.COGNITO_CLIENT_SECRET ??
+        null,
+    },
+    openai: {
+      apiKey:
+        (parsed.openai as Record<string, unknown>)?.apiKey ??
+        process.env.OPENAI_API_KEY ??
+        null,
+      model:
+        (parsed.openai as Record<string, unknown>)?.model ??
+        process.env.OPENAI_MODEL ??
+        'gpt-4o-mini',
+    },
+    anthropic: {
+      apiKey:
+        (parsed.anthropic as Record<string, unknown>)?.apiKey ??
+        process.env.ANTHROPIC_API_KEY ??
+        null,
+      model:
+        (parsed.anthropic as Record<string, unknown>)?.model ??
+        process.env.ANTHROPIC_MODEL ??
+        'claude-3-5-haiku-20241022',
+    },
+    aiProvider: (() => {
+      const fromFile = parsed.aiProvider;
+      const fromEnv = process.env.FABRIC_AI_PROVIDER;
+      const pick = (v: unknown): 'auto' | 'anthropic' | 'openai' | undefined =>
+        v === 'auto' || v === 'anthropic' || v === 'openai' ? v : undefined;
+      return pick(fromFile) ?? pick(fromEnv) ?? 'auto';
+    })(),
+    ses: {
+      fromEmail:
+        (parsed.ses as Record<string, unknown>)?.fromEmail ??
+        process.env.SES_FROM_EMAIL ??
+        null,
+      escalationToEmail:
+        (parsed.ses as Record<string, unknown>)?.escalationToEmail ??
+        process.env.FABRIC_ESCALATION_TO_EMAIL ??
+        process.env.SES_ESCALATION_TO_EMAIL ??
+        null,
+    },
+    docker: {
+      baseImage:
+        (parsed.docker as Record<string, unknown>)?.baseImage ??
+        process.env.DOCKER_BASE_IMAGE ??
+        'fractliodevops/agentlangcli:latest',
+    },
+    eks: {
+      namespace:
+        (parsed.eks as Record<string, unknown>)?.namespace ??
+        process.env.EKS_NAMESPACE ??
+        'default',
+    },
+    cors: {
+      origins:
+        (parsed.cors as Record<string, unknown>)?.origins ??
+        (process.env.CORS_ORIGINS
+          ? process.env.CORS_ORIGINS.split(',').map((o: string) => o.trim())
+          : ['http://localhost:5173', 'http://127.0.0.1:5173']),
+    },
+  };
+
+  const result = configSchema.safeParse(config);
+  if (!result.success) {
+    logger.error(`Invalid configuration: ${result.error.message}`);
+    throw new Error(`Invalid Fabric configuration: ${result.error.message}`);
+  }
+
+  return result.data;
+});

package/apps/fabric/src/database/entities/deployment-event.entity.ts

@@ -0,0 +1,33 @@
+import { Entity, Column, PrimaryColumn, Index } from 'typeorm';
+
+@Entity('deployment_events')
+@Index(['projectId', 'employeeId', 'createdAt'])
+@Index(['userId', 'createdAt'])
+export class DeploymentEventEntity {
+  @PrimaryColumn()
+  id!: string;
+
+  @Column({ nullable: true })
+  userId!: string | null;
+
+  @Column()
+  projectId!: string;
+
+  @Column()
+  employeeId!: string;
+
+  @Column()
+  env!: string;
+
+  @Column()
+  type!: string;
+
+  @Column({ type: 'text' })
+  message!: string;
+
+  @Column({ nullable: true, type: 'int' })
+  retryCount!: number | undefined;
+
+  @Column()
+  createdAt!: string;
+}

package/apps/fabric/src/database/entities/environment.entity.ts

@@ -0,0 +1,25 @@
+import { Entity, Column, PrimaryColumn } from 'typeorm';
+
+@Entity('environments')
+export class EnvironmentEntity {
+  @PrimaryColumn()
+  id!: string;
+
+  @Column()
+  name!: string;
+
+  @Column()
+  providerType!: string;
+
+  @Column({ type: 'jsonb', default: {} })
+  envVars!: Record<string, string>;
+
+  @Column({ type: 'jsonb', default: {} })
+  jsonConfig!: Record<string, unknown>;
+
+  @Column()
+  createdAt!: string;
+
+  @Column()
+  updatedAt!: string;
+}

package/apps/fabric/src/database/entities/index.ts

@@ -0,0 +1,25 @@
+import { RuntimeEntity } from './runtime.entity';
+import { ProjectEntity } from './project.entity';
+import { DeploymentEventEntity } from './deployment-event.entity';
+import { EnvironmentEntity } from './environment.entity';
+import { UserConfigEntity } from './user-config.entity';
+import { VersionEntity } from './version.entity';
+
+export {
+  RuntimeEntity,
+  ProjectEntity,
+  DeploymentEventEntity,
+  EnvironmentEntity,
+  UserConfigEntity,
+  VersionEntity,
+};
+
+// Array for DatabaseModule config
+export const fabricEntities = [
+  RuntimeEntity,
+  ProjectEntity,
+  DeploymentEventEntity,
+  EnvironmentEntity,
+  UserConfigEntity,
+  VersionEntity,
+];

package/apps/fabric/src/database/entities/project.entity.ts

@@ -0,0 +1,25 @@
+import { Entity, Column, PrimaryColumn } from 'typeorm';
+
+@Entity('projects')
+export class ProjectEntity {
+  @PrimaryColumn()
+  id!: string;
+
+  @Column({ nullable: true })
+  userId!: string | null;
+
+  @Column()
+  name!: string;
+
+  @Column()
+  environmentId!: string;
+
+  @Column({ nullable: true })
+  dbName!: string | null;
+
+  @Column()
+  createdAt!: string;
+
+  @Column()
+  updatedAt!: string;
+}

package/apps/fabric/src/database/entities/runtime.entity.ts

@@ -0,0 +1,55 @@
+import { Entity, Column, PrimaryColumn } from 'typeorm';
+
+@Entity('runtimes')
+export class RuntimeEntity {
+  @PrimaryColumn()
+  projectId!: string;
+
+  @PrimaryColumn()
+  employeeId!: string;
+
+  @PrimaryColumn()
+  env!: string;
+
+  @Column({ nullable: true })
+  userId!: string | null;
+
+  @Column()
+  runtime!: string;
+
+  @Column({ nullable: true })
+  deployedAt!: string | null;
+
+  @Column({ nullable: true })
+  lastError!: string | null;
+
+  @Column({ nullable: true })
+  versionId!: string | null;
+
+  @Column({ nullable: true })
+  publishedAt!: string | null;
+
+  @Column({ default: 0 })
+  moduleCount!: number;
+
+  @Column({ nullable: true })
+  containerId!: string | null;
+
+  @Column({ nullable: true, type: 'int' })
+  port!: number | null;
+
+  @Column({ nullable: true })
+  environmentId!: string | null;
+
+  @Column({ nullable: true })
+  projectPath!: string | null;
+
+  @Column({ type: 'jsonb', nullable: true })
+  source!: unknown;
+
+  @Column({ default: 0 })
+  healthcheckRetryCount!: number;
+
+  @Column({ type: 'jsonb', nullable: true })
+  envVars!: Record<string, string> | null;
+}

package/apps/fabric/src/database/entities/user-config.entity.ts

@@ -0,0 +1,22 @@
+import { Entity, Column, PrimaryColumn } from 'typeorm';
+
+@Entity('user_configs')
+export class UserConfigEntity {
+  @PrimaryColumn()
+  userId!: string;
+
+  @Column()
+  healthcheckMaxRetries!: number;
+
+  @Column({ nullable: true })
+  notificationFromEmail!: string | null;
+
+  @Column({ type: 'jsonb', default: [] })
+  notificationToEmails!: string[];
+
+  @Column()
+  createdAt!: string;
+
+  @Column()
+  updatedAt!: string;
+}

package/apps/fabric/src/database/entities/version.entity.ts

@@ -0,0 +1,22 @@
+import { Entity, Column, PrimaryGeneratedColumn } from 'typeorm';
+
+@Entity('versions')
+export class VersionEntity {
+  @PrimaryGeneratedColumn()
+  rowId!: number;
+
+  @Column()
+  versionId!: string;
+
+  @Column()
+  projectId!: string;
+
+  @Column()
+  employeeId!: string;
+
+  @Column()
+  createdAt!: string;
+
+  @Column({ type: 'jsonb', default: {} })
+  snapshot!: Record<string, unknown>;
+}

package/apps/fabric/src/database/migrations-data-source.ts

@@ -0,0 +1,27 @@
+import { DataSource } from 'typeorm';
+import {
+  RuntimeEntity,
+  ProjectEntity,
+  DeploymentEventEntity,
+  EnvironmentEntity,
+  UserConfigEntity,
+  VersionEntity,
+} from './entities';
+
+export default new DataSource({
+  type: 'postgres',
+  host: process.env.DB_HOST ?? 'localhost',
+  port: Number(process.env.DB_PORT) || 5432,
+  username: process.env.DB_USER ?? 'postgres',
+  password: process.env.DB_PASSWORD ?? 'postgres',
+  database: process.env.EMBEDDED_DB_NAME ?? 'fabric',
+  entities: [
+    RuntimeEntity,
+    ProjectEntity,
+    DeploymentEventEntity,
+    EnvironmentEntity,
+    UserConfigEntity,
+    VersionEntity,
+  ],
+  migrations: ['apps/fabric/src/database/migrations/*.ts'],
+});

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

@@ -0,0 +1,27 @@
+import { Controller, Get, Query } from '@nestjs/common';
+import { DeploymentEventsService } from './deployment-events.service';
+
+@Controller('deployment-events')
+export class DeploymentEventsController {
+  constructor(
+    private readonly deploymentEventsService: DeploymentEventsService,
+  ) {}
+
+  @Get()
+  list(
+    @Query('projectId') projectId?: string,
+    @Query('employeeId') employeeId?: string,
+    @Query('limit') limitRaw?: string,
+  ) {
+    const limit =
+      limitRaw != null && limitRaw !== ''
+        ? Math.min(500, Math.max(1, parseInt(limitRaw, 10) || 100))
+        : 100;
+    const data = this.deploymentEventsService.getAll({
+      projectId: projectId || undefined,
+      employeeId: employeeId || undefined,
+      limit,
+    });
+    return { data };
+  }
+}

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

@@ -0,0 +1,11 @@
+import { Module } from '@nestjs/common';
+import { DeploymentEventsController } from './deployment-events.controller';
+import { DeploymentEventsService } from './deployment-events.service';
+import { DeploymentEventsStore } from './deployment-events.store';
+
+@Module({
+  controllers: [DeploymentEventsController],
+  providers: [DeploymentEventsService, DeploymentEventsStore],
+  exports: [DeploymentEventsService],
+})
+export class DeploymentEventsModule {}

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

@@ -0,0 +1,58 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { DeploymentEventsStore } from './deployment-events.store';
+import type {
+  DeploymentEvent,
+  DeploymentEventType,
+} from './deployment-events.types';
+
+@Injectable()
+export class DeploymentEventsService {
+  private readonly logger = new Logger(DeploymentEventsService.name);
+
+  constructor(private readonly store: DeploymentEventsStore) {}
+
+  create(data: {
+    userId?: string | null;
+    projectId: string;
+    employeeId: string;
+    env: string;
+    type: DeploymentEventType;
+    message: string;
+    retryCount?: number;
+  }): DeploymentEvent {
+    const event: DeploymentEvent = {
+      id: this.store.generateId(),
+      userId: data.userId ?? null,
+      projectId: data.projectId,
+      employeeId: data.employeeId,
+      env: data.env,
+      type: data.type,
+      message: data.message,
+      retryCount: data.retryCount,
+      createdAt: new Date().toISOString(),
+    };
+
+    this.store.create(event);
+    this.logger.debug(
+      `Event [${data.type}] ${data.projectId}/${data.employeeId} (${data.env}): ${data.message}`,
+    );
+    return event;
+  }
+
+  getAll(options?: {
+    projectId?: string;
+    employeeId?: string;
+    userId?: string;
+    limit?: number;
+  }): DeploymentEvent[] {
+    return this.store.getAll(options);
+  }
+
+  getByProjectAndEmployee(
+    projectId: string,
+    employeeId: string,
+    options?: { limit?: number },
+  ): DeploymentEvent[] {
+    return this.store.getByProjectAndEmployee(projectId, employeeId, options);
+  }
+}