@agentlang/agentmanager 0.0.3

package/apps/agentmanager/src/inbox/inbox.service.ts

@@ -0,0 +1,209 @@
+import { Injectable, Inject, Logger } from '@nestjs/common';
+import { mkdir, readdir, readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import {
+  INBOXES_PATH,
+  InboxMessage,
+  MessageFilter,
+  isEventContinuation,
+  HttpContinuation,
+  MessageNotFoundError,
+  InvalidMessageOperationError,
+  ContinuationFailedError,
+} from '@app/project-provider';
+
+@Injectable()
+export class InboxService {
+  private readonly logger = new Logger(InboxService.name);
+
+  constructor(@Inject(INBOXES_PATH) private readonly inboxesPath: string) {}
+
+  private inboxDir(inbox: string): string {
+    return join(this.inboxesPath, inbox);
+  }
+
+  private messagePath(inbox: string, messageId: string): string {
+    return join(this.inboxesPath, inbox, `${messageId}.json`);
+  }
+
+  private async readMessage(
+    inbox: string,
+    messageId: string,
+  ): Promise<InboxMessage> {
+    try {
+      const raw = await readFile(this.messagePath(inbox, messageId), 'utf-8');
+      return JSON.parse(raw) as InboxMessage;
+    } catch {
+      throw new MessageNotFoundError(inbox, messageId);
+    }
+  }
+
+  private async writeMessage(message: InboxMessage): Promise<void> {
+    const dir = this.inboxDir(message.inbox);
+    await mkdir(dir, { recursive: true });
+    await writeFile(
+      this.messagePath(message.inbox, message.id),
+      JSON.stringify(message, null, 2),
+      'utf-8',
+    );
+  }
+
+  async pushMessage(
+    inbox: string,
+    message: Omit<InboxMessage, 'id' | 'status' | 'createdAt'>,
+  ): Promise<InboxMessage> {
+    const full: InboxMessage = {
+      ...message,
+      id: randomUUID(),
+      inbox,
+      status: message.kind === 'notification' ? 'unread' : 'pending',
+      createdAt: new Date().toISOString(),
+    };
+    await this.writeMessage(full);
+    return full;
+  }
+
+  async listMessages(
+    inbox: string,
+    filter?: MessageFilter,
+  ): Promise<InboxMessage[]> {
+    const dir = this.inboxDir(inbox);
+    let entries: string[];
+    try {
+      const dirEntries = await readdir(dir);
+      entries = dirEntries.filter((e) => e.endsWith('.json'));
+    } catch {
+      return [];
+    }
+
+    const messages: InboxMessage[] = [];
+    for (const entry of entries) {
+      const raw = await readFile(join(dir, entry), 'utf-8');
+      messages.push(JSON.parse(raw) as InboxMessage);
+    }
+
+    let filtered = messages;
+    if (filter) {
+      if (filter.status) {
+        filtered = filtered.filter((m) => m.status === filter.status);
+      }
+      if (filter.kind) {
+        filtered = filtered.filter((m) => m.kind === filter.kind);
+      }
+      if (filter.from) {
+        filtered = filtered.filter((m) => m.from.id === filter.from);
+      }
+    }
+
+    filtered.sort(
+      (a, b) =>
+        new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime(),
+    );
+
+    return filtered;
+  }
+
+  async getMessage(inbox: string, messageId: string): Promise<InboxMessage> {
+    return this.readMessage(inbox, messageId);
+  }
+
+  async markRead(inbox: string, messageId: string): Promise<InboxMessage> {
+    const msg = await this.readMessage(inbox, messageId);
+
+    if (msg.kind !== 'notification') {
+      throw new InvalidMessageOperationError(
+        'Only notifications can be marked as read',
+      );
+    }
+    if (msg.status !== 'unread') {
+      throw new InvalidMessageOperationError('Message is already read');
+    }
+
+    msg.status = 'read';
+    await this.writeMessage(msg);
+    return msg;
+  }
+
+  async respond(
+    inbox: string,
+    messageId: string,
+    selected: string,
+    input?: string,
+  ): Promise<InboxMessage> {
+    const msg = await this.readMessage(inbox, messageId);
+
+    if (msg.kind !== 'action') {
+      throw new InvalidMessageOperationError(
+        'Only action messages can be responded to',
+      );
+    }
+    if (msg.status !== 'pending') {
+      throw new InvalidMessageOperationError(
+        'Message has already been responded to',
+      );
+    }
+    if (!msg.action!.responses.includes(selected)) {
+      throw new InvalidMessageOperationError(
+        `Invalid response '${selected}'. Valid responses: ${msg.action!.responses.join(', ')}`,
+      );
+    }
+
+    msg.status = 'responded';
+    msg.response = {
+      selected,
+      ...(input !== undefined ? { input } : {}),
+      respondedAt: new Date().toISOString(),
+    };
+    await this.writeMessage(msg);
+    return msg;
+  }
+
+  async executeContinuation(message: InboxMessage): Promise<void> {
+    if (!message.response || !message.action) return;
+
+    const continuation =
+      message.action.continuations[message.response.selected];
+    if (!continuation) return;
+
+    if (isEventContinuation(continuation)) {
+      return;
+    }
+
+    const httpCont = continuation as HttpContinuation;
+
+    let body: Record<string, unknown> | undefined;
+    if (httpCont.method !== 'GET' && httpCont.method !== 'DELETE') {
+      body = {
+        ...(httpCont.body ?? {}),
+        ...(message.response.input
+          ? { userInput: message.response.input }
+          : {}),
+      };
+    }
+
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json',
+      ...(httpCont.headers ?? {}),
+    };
+
+    let res: Response;
+    try {
+      res = await fetch(httpCont.url, {
+        method: httpCont.method,
+        headers,
+        ...(body ? { body: JSON.stringify(body) } : {}),
+      });
+    } catch (err) {
+      const msg = `Continuation failed: ${httpCont.method} ${httpCont.url} — ${err instanceof Error ? err.message : err}`;
+      this.logger.error(msg, err instanceof Error ? err.stack : undefined);
+      throw new ContinuationFailedError(msg);
+    }
+
+    if (!res.ok) {
+      const msg = `Continuation returned HTTP ${res.status}: ${httpCont.method} ${httpCont.url}`;
+      this.logger.warn(msg);
+      throw new ContinuationFailedError(msg);
+    }
+  }
+}

package/apps/agentmanager/src/main.ts

@@ -0,0 +1,53 @@
+import { NestFactory } from '@nestjs/core';
+import {
+  FastifyAdapter,
+  NestFastifyApplication,
+} from '@nestjs/platform-fastify';
+import { Logger } from '@nestjs/common';
+import { ZodValidationPipe } from 'nestjs-zod';
+import { SwaggerModule, DocumentBuilder } from '@nestjs/swagger';
+import helmet from '@fastify/helmet';
+import { AppModule } from './app.module';
+import { ConfigService } from '@nestjs/config';
+
+async function bootstrap() {
+  const app = await NestFactory.create<NestFastifyApplication>(
+    AppModule,
+    new FastifyAdapter({ bodyLimit: 1_048_576 }),
+  );
+
+  await app.register(helmet as Parameters<typeof app.register>[0], {
+    contentSecurityPolicy: false,
+  });
+
+  const config = app.get(ConfigService);
+  const port = config.get<number>('port', 3001);
+  const corsOrigins = config.get<string[]>('cors.origins', [
+    'http://localhost:3000',
+    'http://127.0.0.1:3000',
+  ]);
+
+  app.enableCors({ origin: corsOrigins, credentials: true });
+  app.setGlobalPrefix('api');
+  app.enableShutdownHooks();
+  app.useGlobalPipes(new ZodValidationPipe());
+
+  const swaggerConfig = new DocumentBuilder()
+    .setTitle('AgentManager API')
+    .setDescription('REST API for managing AI employee swarms')
+    .setVersion('1.0')
+    .build();
+  const document = SwaggerModule.createDocument(app, swaggerConfig);
+  SwaggerModule.setup('docs', app, document);
+
+  await app.listen(port, '0.0.0.0');
+
+  const logger = new Logger('Bootstrap');
+  logger.log(`AgentManager listening on port ${port}`);
+}
+
+bootstrap().catch((err) => {
+  const logger = new Logger('Bootstrap');
+  logger.error(`Failed to start AgentManager: ${err}`);
+  process.exit(1);
+});

package/apps/agentmanager/src/projects/dto/create-project.dto.ts

@@ -0,0 +1,10 @@
+import { createZodDto } from 'nestjs-zod';
+import { z } from 'zod';
+
+export const CreateProjectSchema = z.object({
+  id: z.string().min(1).max(100),
+  name: z.string().min(1).optional(),
+  environmentId: z.string().min(1).optional(),
+});
+
+export class CreateProjectDto extends createZodDto(CreateProjectSchema) {}

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

@@ -0,0 +1,47 @@
+import {
+  Controller,
+  Get,
+  Post,
+  Delete,
+  Param,
+  Body,
+  HttpCode,
+  HttpStatus,
+} from '@nestjs/common';
+import { ProjectsService } from './projects.service';
+import { CreateProjectDto } from './dto/create-project.dto';
+
+@Controller('projects')
+export class ProjectsController {
+  constructor(private readonly projectsService: ProjectsService) {}
+
+  @Get()
+  async listProjects() {
+    const data = await this.projectsService.listProjects();
+    return { data };
+  }
+
+  @Post()
+  @HttpCode(HttpStatus.CREATED)
+  async createProject(@Body() dto: CreateProjectDto) {
+    const metadata =
+      dto.name || dto.environmentId
+        ? {
+            ...(dto.name && { name: dto.name }),
+            ...(dto.environmentId && { environmentId: dto.environmentId }),
+          }
+        : undefined;
+    const project = await this.projectsService.createProject(dto.id, metadata);
+    return {
+      ...project,
+      name: project.name ?? dto.name,
+      environmentId: project.environmentId ?? dto.environmentId,
+    };
+  }
+
+  @Delete(':projectId')
+  @HttpCode(HttpStatus.NO_CONTENT)
+  async deleteProject(@Param('projectId') projectId: string) {
+    return this.projectsService.deleteProject(projectId);
+  }
+}

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

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+import { ProjectsController } from './projects.controller';
+import { ProjectsService } from './projects.service';
+
+@Module({
+  controllers: [ProjectsController],
+  providers: [ProjectsService],
+  exports: [ProjectsService],
+})
+export class ProjectsModule {}

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

@@ -0,0 +1,24 @@
+import { Injectable, Inject } from '@nestjs/common';
+import { REGISTRY_PROVIDER, RegistryProvider } from '@app/project-provider';
+
+@Injectable()
+export class ProjectsService {
+  constructor(
+    @Inject(REGISTRY_PROVIDER) private readonly registry: RegistryProvider,
+  ) {}
+
+  async listProjects() {
+    return this.registry.listProjects();
+  }
+
+  async createProject(
+    id: string,
+    metadata?: { name?: string; environmentId?: string },
+  ) {
+    return this.registry.createProject(id, metadata);
+  }
+
+  async deleteProject(projectId: string) {
+    return this.registry.deleteProject(projectId);
+  }
+}

package/apps/agentmanager/tsconfig.app.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/apps/agentmanager"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "test", "**/*spec.ts"]
+}

package/apps/fabric/Dockerfile

@@ -0,0 +1,22 @@
+FROM node:20-alpine AS builder
+
+WORKDIR /app
+
+COPY package*.json ./
+RUN npm ci
+
+COPY . .
+RUN npx nest build fabric
+
+FROM node:20-alpine
+
+WORKDIR /app
+
+COPY package*.json ./
+RUN npm ci --omit=dev
+
+COPY --from=builder /app/dist/apps/fabric ./dist/apps/fabric
+
+EXPOSE 3003
+
+CMD ["node", "dist/apps/fabric/src/main.js"]

package/apps/fabric/docker-compose.yml

@@ -0,0 +1,14 @@
+services:
+  postgres:
+    image: postgres:16-alpine
+    environment:
+      POSTGRES_USER: postgres
+      POSTGRES_PASSWORD: postgres
+      POSTGRES_DB: fabric
+    ports:
+      - '5432:5432'
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+
+volumes:
+  postgres_data:

package/apps/fabric/ecosystem.config.cjs

@@ -0,0 +1,17 @@
+module.exports = {
+  apps: [
+    {
+      name: 'fabric',
+      script: 'dist/apps/fabric/src/main.js',
+      cwd: '../../',
+      instances: 1,
+      exec_mode: 'fork',
+      env: {
+        NODE_ENV: 'development',
+      },
+      env_production: {
+        NODE_ENV: 'production',
+      },
+    },
+  ],
+};

package/apps/fabric/src/ai-agent/ai-agent.module.ts

@@ -0,0 +1,43 @@
+import { Module } from '@nestjs/common';
+import {
+  AiAgentService,
+  ANTHROPIC_MODULE,
+  OPENAI_MODULE,
+} from './ai-agent.service';
+
+@Module({
+  providers: [
+    AiAgentService,
+    {
+      provide: OPENAI_MODULE,
+      useFactory: async () => {
+        try {
+          const name = 'openai';
+          /* Optional SDK — dynamic import; types are not available at compile time */
+          const mod = (await import(name)) as {
+            default?: unknown;
+          };
+          return mod.default ?? mod;
+        } catch {
+          return null;
+        }
+      },
+    },
+    {
+      provide: ANTHROPIC_MODULE,
+      useFactory: async () => {
+        try {
+          const name = '@anthropic-ai/sdk';
+          const mod = (await import(name)) as {
+            default?: unknown;
+          };
+          return mod.default ?? mod;
+        } catch {
+          return null;
+        }
+      },
+    },
+  ],
+  exports: [AiAgentService],
+})
+export class AiAgentModule {}