@agentlang/agentmanager 0.0.3

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

@@ -0,0 +1,279 @@
+import { Injectable, Inject, Logger } from '@nestjs/common';
+import type { ConfigType } from '@nestjs/config';
+import { execFile, spawn } from 'node:child_process';
+import { promisify } from 'node:util';
+import fabricConfig from '../config/configuration';
+import type {
+  DeploymentProvider,
+  ProviderDeployContext,
+  ProviderDeployResult,
+} from './provider.interface';
+
+const exec = promisify(execFile);
+
+@Injectable()
+export class EksProvider implements DeploymentProvider {
+  readonly type = 'eks';
+  readonly capabilities = ['github'] as const;
+  private readonly logger = new Logger(EksProvider.name);
+
+  constructor(
+    @Inject(fabricConfig.KEY)
+    private readonly config: ConfigType<typeof fabricConfig>,
+  ) {}
+
+  private async kubectl(args: string[], timeout = 30000): Promise<string> {
+    const { stdout } = await exec('kubectl', args, { timeout });
+    return stdout;
+  }
+
+  async isAvailable(): Promise<boolean> {
+    try {
+      await exec('kubectl', ['cluster-info'], { timeout: 10000 });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async deploy(
+    processName: string,
+    projectPath: string,
+    envVars: Record<string, string>,
+    port: number,
+    _context?: ProviderDeployContext,
+  ): Promise<ProviderDeployResult> {
+    try {
+      // Delete existing deployment (best-effort)
+      try {
+        await this.kubectl(['delete', 'deployment', processName]);
+      } catch (err) {
+        this.logger.debug(
+          `No existing deployment ${processName} to delete: ${err instanceof Error ? err.message : err}`,
+        );
+      }
+
+      const env = { ...envVars, PORT: String(port) };
+      const envBlock = Object.entries(env)
+        .map(
+          ([k, v]) => `            - name: ${k}\n              value: "${v}"`,
+        )
+        .join('\n');
+
+      const manifest = `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: ${processName}
+  labels:
+    app: ${processName}
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      app: ${processName}
+  template:
+    metadata:
+      labels:
+        app: ${processName}
+    spec:
+      containers:
+        - name: ${processName}
+          image: ${processName}:latest
+          ports:
+            - containerPort: ${port}
+          env:
+${envBlock}
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: ${processName}
+spec:
+  selector:
+    app: ${processName}
+  ports:
+    - port: ${port}
+      targetPort: ${port}
+  type: ClusterIP
+`.trim();
+
+      await exec('sh', ['-c', `echo '${manifest}' | kubectl apply -f -`], {
+        timeout: 60000,
+      });
+
+      this.logger.log(`Deployed ${processName} to EKS on port ${port}`);
+
+      return { success: true, containerId: processName };
+    } 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.kubectl([
+      'delete',
+      'deployment,service',
+      containerId,
+      '--ignore-not-found',
+    ]);
+    this.logger.log(`Stopped EKS deployment ${containerId}`);
+  }
+
+  async restart(containerId: string): Promise<void> {
+    await this.kubectl(['rollout', 'restart', `deployment/${containerId}`]);
+    this.logger.log(`Restarted EKS deployment ${containerId}`);
+  }
+
+  async getStatus(
+    containerId: string,
+  ): Promise<'running' | 'stopped' | 'not_found'> {
+    try {
+      const output = await this.kubectl([
+        'get',
+        'deployment',
+        containerId,
+        '-o',
+        'jsonpath={.status.availableReplicas}',
+      ]);
+      const replicas = parseInt(output.trim(), 10);
+      return replicas > 0 ? 'running' : 'stopped';
+    } catch (err) {
+      this.logger.warn(
+        `Failed to get status for deployment ${containerId}: ${err instanceof Error ? err.message : err}`,
+      );
+      return 'not_found';
+    }
+  }
+
+  async scaleUp(containerId: string): Promise<void> {
+    try {
+      const output = await this.kubectl([
+        'get',
+        'deployment',
+        containerId,
+        '-o',
+        'jsonpath={.spec.replicas}',
+      ]);
+      const current = parseInt(output.trim(), 10) || 1;
+      const next = Math.min(current + 1, 10);
+      await this.kubectl([
+        'scale',
+        `deployment/${containerId}`,
+        `--replicas=${next}`,
+      ]);
+      this.logger.log(
+        `Scaled EKS deployment ${containerId} from ${current} to ${next} replicas`,
+      );
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      this.logger.error(`Failed to scale ${containerId}: ${message}`);
+      throw err;
+    }
+  }
+
+  async getLogs(containerId: string, tail = 100): Promise<string> {
+    try {
+      return await this.kubectl([
+        'logs',
+        `deployment/${containerId}`,
+        `--tail=${tail}`,
+      ]);
+    } catch (err) {
+      this.logger.warn(
+        `Failed to fetch logs for deployment ${containerId}: ${err instanceof Error ? err.message : err}`,
+      );
+      return '';
+    }
+  }
+
+  async checkHealth(
+    containerId: string,
+    port: number,
+  ): Promise<{
+    ok: boolean;
+    status?: number;
+    error?: string;
+    healthData?: Record<string, unknown>;
+  }> {
+    const namespace = this.config.eks.namespace;
+    const localPort = 30999;
+
+    const pf = spawn(
+      'kubectl',
+      [
+        'port-forward',
+        `svc/${containerId}`,
+        `${localPort}:${port}`,
+        '-n',
+        namespace,
+      ],
+      { stdio: 'ignore' },
+    );
+
+    let resolved = false;
+    let resolveFn!: (r: {
+      ok: boolean;
+      status?: number;
+      error?: string;
+      healthData?: Record<string, unknown>;
+    }) => void;
+    const p = new Promise<{
+      ok: boolean;
+      status?: number;
+      error?: string;
+      healthData?: Record<string, unknown>;
+    }>((r) => {
+      resolveFn = r;
+    });
+
+    const done = (result: {
+      ok: boolean;
+      status?: number;
+      error?: string;
+      healthData?: Record<string, unknown>;
+    }) => {
+      if (resolved) return;
+      resolved = true;
+      pf.kill('SIGTERM');
+      resolveFn(result);
+    };
+
+    pf.on('error', () =>
+      done({ ok: false, error: 'kubectl port-forward failed' }),
+    );
+
+    setTimeout(() => {
+      void (async () => {
+        if (resolved) return;
+        try {
+          const res = await fetch(`http://localhost:${localPort}/health`);
+          const text = await res.text();
+          let healthData: Record<string, unknown> | undefined;
+          try {
+            healthData = text
+              ? (JSON.parse(text) as Record<string, unknown>)
+              : undefined;
+          } catch {
+            //
+          }
+          done({
+            ok: res.ok,
+            status: res.status,
+            error: res.ok ? undefined : `HTTP ${res.status}`,
+            healthData,
+          });
+        } catch (err) {
+          done({
+            ok: false,
+            error: err instanceof Error ? err.message : String(err),
+          });
+        }
+      })();
+    }, 2500);
+
+    return p;
+  }
+}

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

@@ -0,0 +1,205 @@
+import { Inject, Injectable, Logger, Optional } from '@nestjs/common';
+import { execFile } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { join, resolve as pathResolve } from 'node:path';
+import { promisify } from 'node:util';
+import fabricConfig from '../config/configuration';
+import type {
+  DeploymentProvider,
+  ProviderDeployContext,
+  ProviderDeployResult,
+} from './provider.interface';
+
+const exec = promisify(execFile);
+
+@Injectable()
+export class Pm2Provider implements DeploymentProvider {
+  readonly type = 'pm2';
+  readonly capabilities = ['github', 'local'] as const;
+  private readonly logger = new Logger(Pm2Provider.name);
+  private pm2Cmd: string | null = null;
+
+  constructor(
+    @Optional()
+    @Inject(fabricConfig.KEY)
+    private readonly fabricConfig?: { registryPath: string },
+  ) {}
+
+  private resolveRegistryBase(): string {
+    const raw =
+      this.fabricConfig?.registryPath ??
+      process.env.REGISTRY_PATH ??
+      './registry';
+    return pathResolve(raw);
+  }
+
+  /** Prefer the registry copy (registry/projectId/employeeId) when present; else the resolved source path. */
+  private resolveRunPath(
+    projectPath: string,
+    context?: ProviderDeployContext,
+  ): string {
+    if (!context) return projectPath;
+    const registryRunPath = join(
+      this.resolveRegistryBase(),
+      context.projectId,
+      context.employeeId,
+    );
+    if (existsSync(registryRunPath)) {
+      this.logger.log(`PM2 run path: registry copy at ${registryRunPath}`);
+      return registryRunPath;
+    }
+    this.logger.debug(
+      `Registry path not found (${registryRunPath}), using resolved source: ${projectPath}`,
+    );
+    return projectPath;
+  }
+
+  private async resolvePm2(): Promise<string> {
+    if (this.pm2Cmd) return this.pm2Cmd;
+
+    const fromEnv = process.env.PM2_BIN?.trim();
+    if (fromEnv) {
+      try {
+        await exec(fromEnv, ['--version'], { timeout: 5000 });
+        this.pm2Cmd = fromEnv;
+        return fromEnv;
+      } catch {
+        this.logger.warn(
+          `PM2_BIN is set but "${fromEnv}" --version failed; falling back to PATH`,
+        );
+      }
+    }
+
+    for (const cmd of ['pm2', 'npx']) {
+      try {
+        const args = cmd === 'npx' ? ['pm2', '--version'] : ['--version'];
+        await exec(cmd, args, { timeout: 5000 });
+        this.pm2Cmd = cmd === 'npx' ? 'npx' : 'pm2';
+        return this.pm2Cmd;
+      } catch {
+        continue;
+      }
+    }
+
+    throw new Error('pm2 is not available');
+  }
+
+  private async pm2(args: string[]): Promise<string> {
+    const cmd = await this.resolvePm2();
+    const fullArgs = cmd === 'npx' ? ['pm2', ...args] : args;
+    const { stdout } = await exec(cmd, fullArgs, { timeout: 30000 });
+    return stdout;
+  }
+
+  /** Quoted or bare `pm2` / `npx pm2` for `sh -c` deploy lines. */
+  private async pm2ShellPrefix(): Promise<string> {
+    const cmd = await this.resolvePm2();
+    if (cmd === 'npx') return 'npx pm2';
+    if (cmd.includes('/') || cmd.includes('\\')) {
+      return `'${cmd.replace(/'/g, "'\\''")}'`;
+    }
+    return cmd;
+  }
+
+  async isAvailable(): Promise<boolean> {
+    try {
+      await this.resolvePm2();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async deploy(
+    processName: string,
+    projectPath: string,
+    envVars: Record<string, string>,
+    port: number,
+    context?: ProviderDeployContext,
+  ): Promise<ProviderDeployResult> {
+    try {
+      // Delete any existing process with this name (best-effort)
+      try {
+        await this.pm2(['delete', processName]);
+      } catch (err) {
+        this.logger.debug(
+          `No existing process ${processName} to delete: ${err instanceof Error ? err.message : err}`,
+        );
+      }
+
+      const env = { ...envVars, PORT: String(port) };
+      const envPrefix = Object.entries(env)
+        .map(([k, v]) => `${k}='${v}'`)
+        .join(' ');
+
+      const cliPath = pathResolve(
+        process.cwd(),
+        './node_modules/agentlang/bin/cli.js',
+      );
+      const runPath = this.resolveRunPath(projectPath, context);
+
+      const entireCommand = `${envPrefix} ${await this.pm2ShellPrefix()} start ${cliPath} --name ${processName} -- run .`;
+      console.log('PM2 Deploy Command:', entireCommand);
+      // cd to runPath before running the command
+      await exec('sh', ['-c', `cd '${runPath}' && ${entireCommand}`], {
+        timeout: 30000,
+      });
+
+      this.logger.log(`Started PM2 process ${processName} on port ${port}`);
+
+      return { success: true, containerId: processName };
+    } 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.pm2(['delete', containerId]);
+    this.logger.log(`Stopped PM2 process ${containerId}`);
+  }
+
+  async restart(containerId: string): Promise<void> {
+    await this.pm2(['restart', containerId]);
+    this.logger.log(`Restarted PM2 process ${containerId}`);
+  }
+
+  async getStatus(
+    containerId: string,
+  ): Promise<'running' | 'stopped' | 'not_found'> {
+    try {
+      const output = await this.pm2(['jlist']);
+      const processes = JSON.parse(output) as Array<{
+        name: string;
+        pm2_env: { status: string };
+      }>;
+
+      const proc = processes.find((p) => p.name === containerId);
+      if (!proc) return 'not_found';
+      return proc.pm2_env.status === 'online' ? 'running' : 'stopped';
+    } catch (err) {
+      this.logger.warn(
+        `Failed to get status for process ${containerId}: ${err instanceof Error ? err.message : err}`,
+      );
+      return 'not_found';
+    }
+  }
+
+  async getLogs(containerId: string, tail = 100): Promise<string> {
+    try {
+      return await this.pm2([
+        'logs',
+        containerId,
+        '--nostream',
+        '--lines',
+        String(tail),
+      ]);
+    } catch (err) {
+      this.logger.warn(
+        `Failed to fetch logs for process ${containerId}: ${err instanceof Error ? err.message : err}`,
+      );
+      return '';
+    }
+  }
+}

package/apps/fabric/src/providers/port-allocator.ts

@@ -0,0 +1,57 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { createServer } from 'node:net';
+import { RuntimeStore } from '../employees/runtime.store';
+
+const PORT_MIN = 10000;
+const PORT_MAX = 65535;
+const MAX_ATTEMPTS = 100;
+
+@Injectable()
+export class PortAllocator {
+  private readonly logger = new Logger(PortAllocator.name);
+
+  constructor(private readonly runtimeStore: RuntimeStore) {}
+
+  allocate(): number {
+    const usedPorts = this.runtimeStore.getUsedPorts();
+
+    for (let i = 0; i < MAX_ATTEMPTS; i++) {
+      const port =
+        Math.floor(Math.random() * (PORT_MAX - PORT_MIN + 1)) + PORT_MIN;
+      if (!usedPorts.has(port)) {
+        return port;
+      }
+    }
+
+    throw new Error(
+      `Failed to allocate a free port after ${MAX_ATTEMPTS} attempts`,
+    );
+  }
+
+  async allocateVerified(): Promise<number> {
+    const usedPorts = this.runtimeStore.getUsedPorts();
+
+    for (let i = 0; i < MAX_ATTEMPTS; i++) {
+      const port =
+        Math.floor(Math.random() * (PORT_MAX - PORT_MIN + 1)) + PORT_MIN;
+      if (!usedPorts.has(port) && (await this.isPortFree(port))) {
+        return port;
+      }
+    }
+
+    throw new Error(
+      `Failed to allocate a verified free port after ${MAX_ATTEMPTS} attempts`,
+    );
+  }
+
+  private isPortFree(port: number): Promise<boolean> {
+    return new Promise((resolve) => {
+      const server = createServer();
+      server.once('error', () => resolve(false));
+      server.once('listening', () => {
+        server.close(() => resolve(true));
+      });
+      server.listen(port, '127.0.0.1');
+    });
+  }
+}

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

@@ -0,0 +1,32 @@
+import { Injectable } from '@nestjs/common';
+import type { DeploymentProvider } from './provider.interface';
+import { Pm2Provider } from './pm2-provider';
+import { DockerProvider } from './docker-provider';
+import { EksProvider } from './eks-provider';
+
+@Injectable()
+export class ProviderFactory {
+  private readonly providers = new Map<string, DeploymentProvider>();
+
+  constructor(
+    pm2Provider: Pm2Provider,
+    dockerProvider: DockerProvider,
+    eksProvider: EksProvider,
+  ) {
+    this.providers.set('pm2', pm2Provider);
+    this.providers.set('docker', dockerProvider);
+    this.providers.set('eks', eksProvider);
+  }
+
+  get(type: string): DeploymentProvider {
+    const provider = this.providers.get(type);
+    if (!provider) {
+      throw new Error(`No provider registered for type: ${type}`);
+    }
+    return provider;
+  }
+
+  getDefault(): DeploymentProvider {
+    return this.get('pm2');
+  }
+}

package/apps/fabric/src/providers/provider.interface.ts

@@ -0,0 +1,50 @@
+export type ProviderCapability = 'github' | 'local';
+
+/** Passed to providers so PM2 can run from the on-disk registry copy (registry/projectId/employeeId). */
+export interface ProviderDeployContext {
+  projectId: string;
+  employeeId: string;
+}
+
+export interface ProviderDeployResult {
+  success: boolean;
+  containerId?: string;
+  error?: string;
+}
+
+export interface DeploymentProvider {
+  readonly type: string;
+  readonly capabilities: readonly ProviderCapability[];
+
+  deploy(
+    processName: string,
+    projectPath: string,
+    envVars: Record<string, string>,
+    port: number,
+    context?: ProviderDeployContext,
+  ): Promise<ProviderDeployResult>;
+
+  stop(containerId: string): Promise<void>;
+
+  restart(containerId: string): Promise<void>;
+
+  getStatus(containerId: string): Promise<'running' | 'stopped' | 'not_found'>;
+
+  getLogs(containerId: string, tail?: number): Promise<string>;
+
+  isAvailable(): Promise<boolean>;
+
+  scaleUp?(containerId: string): Promise<void>;
+
+  checkHealth?(
+    containerId: string,
+    port: number,
+  ): Promise<{
+    ok: boolean;
+    status?: number;
+    error?: string;
+    healthData?: Record<string, unknown>;
+  }>;
+}
+
+export const DEPLOYMENT_PROVIDER = Symbol('DEPLOYMENT_PROVIDER');

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

@@ -0,0 +1,26 @@
+import { Module } from '@nestjs/common';
+import {
+  DEPLOYMENT_PROVIDER,
+  type DeploymentProvider,
+} from './provider.interface';
+import { ProviderFactory } from './provider-factory';
+import { Pm2Provider } from './pm2-provider';
+import { DockerProvider } from './docker-provider';
+import { EksProvider } from './eks-provider';
+
+@Module({
+  providers: [
+    Pm2Provider,
+    DockerProvider,
+    EksProvider,
+    ProviderFactory,
+    {
+      provide: DEPLOYMENT_PROVIDER,
+      useFactory: (factory: ProviderFactory): DeploymentProvider =>
+        factory.getDefault(),
+      inject: [ProviderFactory],
+    },
+  ],
+  exports: [DEPLOYMENT_PROVIDER, ProviderFactory],
+})
+export class ProvidersModule {}