@agentlang/agentmanager 0.0.3

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

@@ -0,0 +1,323 @@
+import {
+  Injectable,
+  Inject,
+  Logger,
+  Optional,
+  forwardRef,
+} from '@nestjs/common';
+import { REGISTRY_PROVIDER, RegistryProvider } from '@app/project-provider';
+import { ProjectsDataService } from './projects-data.service';
+import { ProjectsStore } from './projects.store';
+import { EnvironmentsService } from '../environments/environments.service';
+import { PostgresProvisionerService } from '../provisioners/postgres-provisioner.service';
+import { RuntimeStore } from '../employees/runtime.store';
+import { EmployeesService } from '../employees/employees.service';
+import {
+  ProjectNotFoundError,
+  ProjectHasRunningEmployeesError,
+} from './errors/project.errors';
+import type { Project } from './projects.types';
+import type {
+  Env,
+  DeployResult,
+  RuntimeStatus,
+} from '../employees/employees.types';
+import { ACTIVE_DEPLOYMENT_STATUSES } from '../employees/employees.types';
+
+function slugify(name: string): string {
+  return name
+    .toLowerCase()
+    .replace(/\s+/g, '-')
+    .replace(/[^a-z0-9-]/g, '');
+}
+
+@Injectable()
+export class ProjectsService {
+  private readonly logger = new Logger(ProjectsService.name);
+
+  constructor(
+    private readonly store: ProjectsStore,
+    private readonly projectsDataService: ProjectsDataService,
+    private readonly environmentsService: EnvironmentsService,
+    private readonly postgresProvisioner: PostgresProvisionerService,
+    @Inject(forwardRef(() => RuntimeStore))
+    private readonly runtimeStore: RuntimeStore,
+    @Inject(forwardRef(() => EmployeesService))
+    private readonly employeesService: EmployeesService,
+    @Optional()
+    @Inject(REGISTRY_PROVIDER)
+    private readonly registry: RegistryProvider | null,
+  ) {}
+
+  private get useRegistry(): boolean {
+    return this.registry != null;
+  }
+
+  async create(data: {
+    userId?: string | null;
+    id?: string;
+    name: string;
+    environmentId: string;
+  }): Promise<Project> {
+    // Validate environment exists
+    this.environmentsService.get(data.environmentId);
+
+    const now = new Date().toISOString();
+
+    if (this.useRegistry) {
+      const id = data.id ?? slugify(data.name);
+      await this.registry!.createProject(id, {
+        name: data.name,
+        environmentId: data.environmentId,
+      });
+
+      let dbName: string | null = null;
+      const env = this.environmentsService.get(data.environmentId);
+      const storeConfig = env.jsonConfig?.store as
+        | Record<string, unknown>
+        | undefined;
+      if (storeConfig?.type === 'postgres') {
+        try {
+          const creds =
+            await this.postgresProvisioner.createProjectDatabase(id);
+          dbName = creds.dbname;
+          this.logger.log(
+            `Created shared database ${dbName} for project ${id}`,
+          );
+          await this.registry!.updateProjectMetadata(id, { dbName });
+        } catch (err) {
+          this.logger.warn(`Failed to create project database: ${err}`);
+        }
+      }
+
+      await this.registry!.getProject(id);
+      this.logger.log(`Created project ${id} (${data.name}) via registry`);
+      return {
+        id,
+        userId: data.userId ?? null,
+        name: data.name,
+        environmentId: data.environmentId,
+        dbName,
+        createdAt: now,
+        updatedAt: now,
+      };
+    }
+
+    const id = this.store.generateId();
+    let dbName: string | null = null;
+
+    const env = this.environmentsService.get(data.environmentId);
+    const storeConfig = env.jsonConfig?.store as
+      | Record<string, unknown>
+      | undefined;
+    if (storeConfig?.type === 'postgres') {
+      try {
+        const creds = await this.postgresProvisioner.createProjectDatabase(id);
+        dbName = creds.dbname;
+        this.logger.log(`Created shared database ${dbName} for project ${id}`);
+      } catch (err) {
+        this.logger.warn(`Failed to create project database: ${err}`);
+      }
+    }
+
+    const project: Project = {
+      id,
+      userId: data.userId ?? null,
+      name: data.name,
+      environmentId: data.environmentId,
+      dbName,
+      createdAt: now,
+      updatedAt: now,
+    };
+
+    this.store.set(project);
+    this.logger.log(`Created project ${project.id} (${project.name})`);
+    return project;
+  }
+
+  async list(): Promise<Project[]> {
+    return this.projectsDataService.list();
+  }
+
+  async get(id: string): Promise<Project> {
+    const project = await this.projectsDataService.get(id);
+    if (!project) {
+      throw new ProjectNotFoundError(id);
+    }
+    return project;
+  }
+
+  async update(
+    id: string,
+    data: Partial<{ name: string; environmentId: string }>,
+  ): Promise<Project> {
+    const existing = await this.get(id);
+
+    if (data.environmentId) {
+      this.environmentsService.get(data.environmentId);
+    }
+
+    if (this.useRegistry) {
+      await this.registry!.updateProjectMetadata(id, {
+        name: data.name,
+        environmentId: data.environmentId,
+      });
+      return this.get(id);
+    }
+
+    const updated: Project = {
+      ...existing,
+      ...data,
+      updatedAt: new Date().toISOString(),
+    };
+
+    this.store.set(updated);
+    this.logger.log(`Updated project ${id}`);
+    return updated;
+  }
+
+  async delete(id: string): Promise<void> {
+    const project = await this.get(id);
+
+    // Check for running employees
+    const entries = this.runtimeStore.listByProject(id);
+    const active = entries.filter((e) =>
+      ACTIVE_DEPLOYMENT_STATUSES.includes(e.entry.runtime),
+    );
+
+    if (active.length > 0) {
+      throw new ProjectHasRunningEmployeesError(id);
+    }
+
+    // Drop shared database if exists
+    if (project.dbName) {
+      try {
+        await this.postgresProvisioner.dropDatabase(project.dbName);
+        this.logger.log(`Dropped shared database ${project.dbName}`);
+      } catch (err) {
+        this.logger.warn(`Failed to drop project database: ${err}`);
+      }
+    }
+
+    if (this.useRegistry) {
+      await this.registry!.deleteProject(id);
+    } else {
+      this.store.delete(id);
+    }
+    this.logger.log(`Deleted project ${id}`);
+  }
+
+  async deployAll(
+    projectId: string,
+    track: Env,
+    fabricEnvironmentId?: string,
+    userId?: string | null,
+  ): Promise<DeployResult[]> {
+    const project = await this.get(projectId);
+    const resolvedFabricEnvId =
+      fabricEnvironmentId ?? (project.environmentId || undefined);
+
+    // Collect employee IDs: runtime store entries + registry employees (if available)
+    const runtimeEntries = this.runtimeStore.listByProject(projectId);
+    const activeStatuses = new Set(ACTIVE_DEPLOYMENT_STATUSES);
+
+    // Build map of employeeId → runtime status for quick lookup
+    const runtimeByEmployee = new Map<string, RuntimeStatus>();
+    for (const e of runtimeEntries) {
+      if (e.env === track) {
+        runtimeByEmployee.set(e.employeeId, e.entry.runtime);
+      }
+    }
+
+    // Include registry employees that have never been deployed
+    const employeeIds = new Set(
+      runtimeEntries.filter((e) => e.env === track).map((e) => e.employeeId),
+    );
+
+    if (this.registry) {
+      try {
+        const registryEmployees = await this.registry.listEmployees(projectId);
+        for (const emp of registryEmployees) {
+          employeeIds.add(emp.id);
+        }
+      } catch (err) {
+        this.logger.warn(
+          `Could not list registry employees for ${projectId}: ${err}`,
+        );
+      }
+    }
+
+    // Filter out employees that are currently active
+    const deployableIds = [...employeeIds].filter((id) => {
+      const status = runtimeByEmployee.get(id);
+      return !status || !activeStatuses.has(status);
+    });
+
+    const results: DeployResult[] = [];
+
+    for (const employeeId of deployableIds) {
+      try {
+        const result = await this.employeesService.deploy(
+          projectId,
+          employeeId,
+          track,
+          resolvedFabricEnvId,
+          undefined,
+          userId,
+        );
+        results.push(result);
+      } catch (err) {
+        this.logger.warn(
+          `Failed to deploy ${employeeId} in project ${projectId}: ${err}`,
+        );
+      }
+    }
+
+    this.logger.log(
+      `Deploy-all for project ${projectId}: ${results.length}/${deployableIds.length} started`,
+    );
+
+    return results;
+  }
+
+  /**
+   * Stops any active deployment on `track` and removes the runtime record for each employee.
+   */
+  async undeployAll(
+    projectId: string,
+    track: Env,
+    fabricEnvironmentId?: string,
+  ): Promise<Array<{ employeeId: string; removed: boolean }>> {
+    const project = await this.get(projectId);
+    const resolvedFabricEnvId =
+      fabricEnvironmentId ?? (project.environmentId || undefined);
+
+    const runtimeEntries = this.runtimeStore
+      .listByProject(projectId)
+      .filter((e) => e.env === track);
+
+    const results: Array<{ employeeId: string; removed: boolean }> = [];
+
+    for (const e of runtimeEntries) {
+      try {
+        const out = await this.employeesService.undeploy(
+          projectId,
+          e.employeeId,
+          track,
+          resolvedFabricEnvId,
+        );
+        results.push({ employeeId: e.employeeId, removed: out.removed });
+      } catch (err) {
+        this.logger.warn(
+          `Failed to undeploy ${e.employeeId} in project ${projectId}: ${err}`,
+        );
+      }
+    }
+
+    this.logger.log(
+      `Undeploy-all for project ${projectId}: ${results.length}/${runtimeEntries.length} completed`,
+    );
+
+    return results;
+  }
+}

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

@@ -0,0 +1,142 @@
+import {
+  Injectable,
+  OnModuleInit,
+  OnModuleDestroy,
+  Logger,
+} from '@nestjs/common';
+import type { Repository } from 'typeorm';
+import { FileStoreFactory, FileStore, DataSourceService } from '@app/common';
+import { ProjectEntity } from '../database/entities';
+import type { Project } from './projects.types';
+
+interface PersistedData {
+  counter: number;
+  projects: Record<string, Project>;
+}
+
+@Injectable()
+export class ProjectsStore implements OnModuleInit, OnModuleDestroy {
+  private readonly logger = new Logger(ProjectsStore.name);
+  private counter = 0;
+  private readonly projects = new Map<string, Project>();
+  private readonly fileStore: FileStore<PersistedData>;
+  private repo: Repository<ProjectEntity> | null = null;
+
+  constructor(
+    fileStoreFactory: FileStoreFactory,
+    private readonly dataSourceService: DataSourceService,
+  ) {
+    this.fileStore = fileStoreFactory.create<PersistedData>('projects.json');
+  }
+
+  async onModuleInit() {
+    this.repo = this.dataSourceService.getRepository(ProjectEntity);
+
+    if (this.repo) {
+      const rows = await this.repo.find();
+      for (const row of rows) {
+        this.projects.set(row.id, this.entityToProject(row));
+      }
+      // Derive counter from existing IDs
+      for (const id of this.projects.keys()) {
+        const match = id.match(/^proj-(\d+)$/);
+        if (match) {
+          this.counter = Math.max(this.counter, parseInt(match[1], 10));
+        }
+      }
+      this.logger.log(
+        `Loaded ${this.projects.size} projects (counter=${this.counter}) from database`,
+      );
+    } else {
+      const data = await this.fileStore.load();
+      if (data) {
+        this.counter = data.counter ?? 0;
+        if (data.projects) {
+          for (const [key, project] of Object.entries(data.projects)) {
+            this.projects.set(key, project);
+          }
+        }
+        this.logger.log(
+          `Loaded ${this.projects.size} projects (counter=${this.counter}) from disk`,
+        );
+      }
+    }
+  }
+
+  private entityToProject(entity: ProjectEntity): Project {
+    return {
+      id: entity.id,
+      userId: entity.userId,
+      name: entity.name,
+      environmentId: entity.environmentId,
+      dbName: entity.dbName,
+      createdAt: entity.createdAt,
+      updatedAt: entity.updatedAt,
+    };
+  }
+
+  private projectToEntity(project: Project): ProjectEntity {
+    const entity = new ProjectEntity();
+    entity.id = project.id;
+    entity.userId = project.userId;
+    entity.name = project.name;
+    entity.environmentId = project.environmentId;
+    entity.dbName = project.dbName;
+    entity.createdAt = project.createdAt;
+    entity.updatedAt = project.updatedAt;
+    return entity;
+  }
+
+  private persist(project?: Project): void {
+    if (this.repo && project) {
+      this.repo
+        .save(this.projectToEntity(project))
+        .catch((err) => this.logger.error(`Failed to persist project: ${err}`));
+    } else if (!this.repo) {
+      const projects: Record<string, Project> = {};
+      for (const [key, p] of this.projects) {
+        projects[key] = p;
+      }
+      this.fileStore.save({ counter: this.counter, projects });
+    }
+  }
+
+  generateId(): string {
+    return `proj-${++this.counter}`;
+  }
+
+  get(id: string): Project | undefined {
+    return this.projects.get(id);
+  }
+
+  set(project: Project): void {
+    this.projects.set(project.id, project);
+    this.persist(project);
+  }
+
+  delete(id: string): boolean {
+    const result = this.projects.delete(id);
+    if (result && this.repo) {
+      this.repo
+        .delete({ id })
+        .catch((err) => this.logger.error(`Failed to delete project: ${err}`));
+    }
+    if (!this.repo) {
+      this.persist();
+    }
+    return result;
+  }
+
+  list(): Project[] {
+    return [...this.projects.values()];
+  }
+
+  async onModuleDestroy() {
+    if (!this.repo) {
+      await this.fileStore.flush();
+    }
+    this.logger.log(
+      `ProjectsStore shutting down with ${this.projects.size} projects`,
+    );
+  }
+}

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

@@ -0,0 +1,9 @@
+export interface Project {
+  id: string;
+  userId: string | null;
+  name: string;
+  environmentId: string;
+  dbName: string | null;
+  createdAt: string;
+  updatedAt: string;
+}

package/apps/fabric/src/providers/docker-provider.ts

@@ -0,0 +1,141 @@
+import { Injectable, Inject, Logger } from '@nestjs/common';
+import type { ConfigType } from '@nestjs/config';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { resolve } from 'node:path';
+import fabricConfig from '../config/configuration';
+import type {
+  DeploymentProvider,
+  ProviderDeployContext,
+  ProviderDeployResult,
+} from './provider.interface';
+
+const exec = promisify(execFile);
+
+@Injectable()
+export class DockerProvider implements DeploymentProvider {
+  readonly type = 'docker';
+  readonly capabilities = ['github', 'local'] as const;
+  private readonly logger = new Logger(DockerProvider.name);
+
+  constructor(
+    @Inject(fabricConfig.KEY)
+    private readonly config: ConfigType<typeof fabricConfig>,
+  ) {}
+
+  private async docker(args: string[], timeout = 30000): Promise<string> {
+    const { stdout } = await exec('docker', args, { timeout });
+    return stdout;
+  }
+
+  async isAvailable(): Promise<boolean> {
+    try {
+      await exec('docker', ['info'], { timeout: 5000 });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async deploy(
+    processName: string,
+    projectPath: string,
+    envVars: Record<string, string>,
+    port: number,
+    _context?: ProviderDeployContext,
+  ): Promise<ProviderDeployResult> {
+    try {
+      // Remove any existing container with this name (best-effort)
+      try {
+        await this.docker(['rm', '-f', processName]);
+      } catch (err) {
+        this.logger.debug(
+          `No existing container ${processName} to remove: ${err instanceof Error ? err.message : err}`,
+        );
+      }
+
+      const absolutePath = resolve(projectPath);
+      const baseImage = this.config.docker.baseImage;
+
+      const runArgs = [
+        'run',
+        '-d',
+        '--name',
+        processName,
+        '-p',
+        `${port}:${port}`,
+        '-v',
+        `${absolutePath}:/app`,
+        '-w',
+        '/app',
+      ];
+
+      const env = { ...envVars, PORT: String(port) };
+      for (const [k, v] of Object.entries(env)) {
+        runArgs.push('-e', `${k}=${v}`);
+      }
+
+      runArgs.push(
+        baseImage,
+        'sh',
+        '-c',
+        'npm rebuild better-sqlite3 && agent run',
+      );
+
+      const containerId = (await this.docker(runArgs, 120000)).trim();
+
+      this.logger.log(
+        `Started Docker container ${processName} (${containerId.slice(0, 12)}) on port ${port}`,
+      );
+
+      return { success: true, containerId };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      this.logger.error(`Failed to deploy ${processName}: ${message}`);
+      return { success: false, error: message };
+    }
+  }
+
+  async stop(containerId: string): Promise<void> {
+    await this.docker(['rm', '-f', containerId]);
+    this.logger.log(`Stopped Docker container ${containerId}`);
+  }
+
+  async restart(containerId: string): Promise<void> {
+    await this.docker(['restart', containerId]);
+    this.logger.log(`Restarted Docker container ${containerId}`);
+  }
+
+  async getStatus(
+    containerId: string,
+  ): Promise<'running' | 'stopped' | 'not_found'> {
+    try {
+      const output = await this.docker([
+        'inspect',
+        '--format',
+        '{{.State.Status}}',
+        containerId,
+      ]);
+      const status = output.trim();
+      if (status === 'running') return 'running';
+      if (status === 'exited' || status === 'stopped') return 'stopped';
+      return 'stopped';
+    } catch (err) {
+      this.logger.warn(
+        `Failed to inspect container ${containerId}: ${err instanceof Error ? err.message : err}`,
+      );
+      return 'not_found';
+    }
+  }
+
+  async getLogs(containerId: string, tail = 100): Promise<string> {
+    try {
+      return await this.docker(['logs', '--tail', String(tail), containerId]);
+    } catch (err) {
+      this.logger.warn(
+        `Failed to fetch logs for container ${containerId}: ${err instanceof Error ? err.message : err}`,
+      );
+      return '';
+    }
+  }
+}