@agentlang/agentmanager 0.0.3

package/apps/agentcraft/src/sessions/sessions.service.ts

@@ -0,0 +1,277 @@
+import { Injectable } from '@nestjs/common';
+import {
+  ApiAdapterFactory,
+  PipelineStateService,
+  PipelineStepsService,
+  OutputParserService,
+  CraftConfigService,
+  PipelineStep,
+  ReviewAction,
+  TestFailureAction,
+  DomainError,
+  InvalidSessionStateError,
+  STEP_DEFINITIONS,
+} from '@app/agentcraft';
+import type { SSEEvent, ApiAdapterService, CraftConfig } from '@app/agentcraft';
+import { resolve } from 'node:path';
+import { readFile } from 'node:fs/promises';
+import { SessionStore } from './session.store';
+
+@Injectable()
+export class SessionsService {
+  constructor(
+    private readonly stateService: PipelineStateService,
+    private readonly stepsService: PipelineStepsService,
+    private readonly outputParser: OutputParserService,
+    private readonly craftConfig: CraftConfigService,
+    private readonly sessionStore: SessionStore,
+    private readonly adapterFactory: ApiAdapterFactory,
+  ) {}
+
+  async create(params: {
+    name: string;
+    provider?: string;
+    model?: string;
+    apiKey?: string;
+    outputDir?: string;
+  }): Promise<{
+    sessionId: string;
+    projectName: string;
+    outputDir: string;
+    needsResume: boolean;
+  }> {
+    const flags: Partial<CraftConfig> = {
+      provider: params.provider as CraftConfig['provider'],
+      model: params.model,
+      apiKey: params.apiKey,
+      outputDir: params.outputDir,
+    };
+
+    const config = await this.craftConfig.resolve(flags);
+    const outputDir = resolve(config.outputDir, params.name);
+    const adapter = this.adapterFactory.create();
+    const sessionId = this.sessionStore.generateId();
+    const needsResume = await this.stateService.exists(outputDir);
+
+    // Initialize pipeline state
+    if (!needsResume) {
+      const state = this.stateService.createInitial(params.name);
+      await this.stateService.save(outputDir, state);
+    }
+
+    adapter.showInfo(
+      needsResume
+        ? `Resuming project "${params.name}"`
+        : `Starting new project "${params.name}"`,
+    );
+
+    this.sessionStore.set({
+      id: sessionId,
+      adapter,
+      outputDir,
+      projectName: params.name,
+      status: 'running',
+    });
+
+    return { sessionId, projectName: params.name, outputDir, needsResume };
+  }
+
+  async getStatus(sessionId: string) {
+    const session = this.sessionStore.get(sessionId);
+
+    let currentStep: string | null = null;
+    let completedSteps: string[] = [];
+
+    const state = await this.stateService.load(session.outputDir);
+    if (state) {
+      currentStep = state.currentStep;
+      completedSteps = [...state.completedSteps];
+    }
+
+    return {
+      sessionId: session.id,
+      status: session.status,
+      currentStep,
+      completedSteps,
+      waitingFor: session.adapter.waitingFor,
+      error: session.error ?? null,
+    };
+  }
+
+  getOutput(sessionId: string): string {
+    return this.sessionStore.get(sessionId).adapter.output;
+  }
+
+  async getSteps(sessionId: string) {
+    const session = this.sessionStore.get(sessionId);
+    const state = await this.stateService.load(session.outputDir);
+    if (!state) return [];
+
+    return Object.entries(state.outputs).map(([outputFile, output]) => {
+      const stepDef = STEP_DEFINITIONS.find((s) => s.outputFile === outputFile);
+      return {
+        id: stepDef?.id ?? outputFile,
+        name: stepDef?.name ?? outputFile,
+        order: stepDef?.order ?? 0,
+        completed: true,
+        output,
+      };
+    });
+  }
+
+  resolveIdea(sessionId: string, idea: string): void {
+    const session = this.sessionStore.get(sessionId);
+
+    if (session.adapter.waitingFor !== 'idea') {
+      throw new InvalidSessionStateError(
+        `Not waiting for idea. Currently waiting for: ${session.adapter.waitingFor}`,
+      );
+    }
+
+    session.adapter.resolveIdea(idea);
+  }
+
+  resolveAction(
+    sessionId: string,
+    body: {
+      action?: string;
+      feedback?: string;
+      targetStep?: string;
+      resume?: boolean;
+      editStep?: string;
+      editContent?: string;
+      postEditTarget?: string;
+    },
+  ): void {
+    const session = this.sessionStore.get(sessionId);
+    const adapter = session.adapter;
+    const { action, feedback, targetStep } = body;
+
+    // Handle resume
+    if (body.resume !== undefined && adapter.waitingFor === 'resume') {
+      adapter.resolveResume(body.resume);
+      return;
+    }
+
+    // Handle targetStep resolution
+    if (targetStep && adapter.waitingFor === 'targetStep') {
+      this.assertPipelineStep(targetStep);
+      adapter.resolveTargetStep(targetStep);
+      return;
+    }
+
+    // Handle editableStep resolution
+    if (body.editStep && adapter.waitingFor === 'editableStep') {
+      this.assertPipelineStep(body.editStep);
+      adapter.resolveEditableStep(body.editStep);
+      return;
+    }
+
+    // Handle editContent resolution
+    if (
+      body.editContent !== undefined &&
+      adapter.waitingFor === 'editContent'
+    ) {
+      adapter.resolveEditContent(body.editContent);
+      return;
+    }
+
+    // Handle postEditNavigation resolution
+    if (body.postEditTarget && adapter.waitingFor === 'postEditNavigation') {
+      this.assertPipelineStep(body.postEditTarget);
+      adapter.resolvePostEditNavigation(body.postEditTarget);
+      return;
+    }
+
+    // Handle testFailureAction resolution
+    if (action && adapter.waitingFor === 'testFailureAction') {
+      this.assertTestFailureAction(action);
+      adapter.resolveTestFailureAction(action);
+      return;
+    }
+
+    // Handle review action
+    if (action && adapter.waitingFor === 'reviewAction') {
+      this.assertReviewAction(action);
+      adapter.resolveReviewAction(
+        action,
+        feedback,
+        targetStep as PipelineStep | undefined,
+        body.editStep as PipelineStep | undefined,
+        body.editContent,
+        body.postEditTarget as PipelineStep | undefined,
+      );
+      return;
+    }
+
+    throw new InvalidSessionStateError(
+      `Cannot perform action. Currently waiting for: ${adapter.waitingFor}`,
+    );
+  }
+
+  async getFiles(sessionId: string): Promise<string[]> {
+    const session = this.sessionStore.get(sessionId);
+    const state = await this.stateService.load(session.outputDir);
+    if (!state) return [];
+
+    const assemblyOutput = state.outputs['finalApp.md'];
+    if (!assemblyOutput) return [];
+
+    return this.outputParser
+      .parseAssemblyOutput(assemblyOutput)
+      .map((f) => f.filePath);
+  }
+
+  async getFile(sessionId: string, filePath: string): Promise<string> {
+    const session = this.sessionStore.get(sessionId);
+
+    const resolved = resolve(session.outputDir, filePath);
+    if (!resolved.startsWith(resolve(session.outputDir))) {
+      throw new DomainError('Path traversal not allowed', 403);
+    }
+
+    try {
+      return await readFile(resolved, 'utf-8');
+    } catch {
+      throw new DomainError('File not found', 404);
+    }
+  }
+
+  getStream(sessionId: string): {
+    events: readonly SSEEvent[];
+    adapter: ApiAdapterService;
+  } {
+    const session = this.sessionStore.get(sessionId);
+    return { events: session.adapter.events, adapter: session.adapter };
+  }
+
+  private isPipelineStep(step: string): step is PipelineStep {
+    return (Object.values(PipelineStep) as string[]).includes(step);
+  }
+
+  private assertPipelineStep(step: string): asserts step is PipelineStep {
+    if (!this.isPipelineStep(step)) {
+      throw new InvalidSessionStateError(
+        `Invalid step. Must be one of: ${Object.values(PipelineStep).join(', ')}`,
+      );
+    }
+  }
+
+  private assertReviewAction(action: string): asserts action is ReviewAction {
+    if (!(Object.values(ReviewAction) as string[]).includes(action)) {
+      throw new InvalidSessionStateError(
+        `Invalid action. Must be one of: ${Object.values(ReviewAction).join(', ')}`,
+      );
+    }
+  }
+
+  private assertTestFailureAction(
+    action: string,
+  ): asserts action is TestFailureAction {
+    if (!(Object.values(TestFailureAction) as string[]).includes(action)) {
+      throw new InvalidSessionStateError(
+        `Invalid action. Must be one of: ${Object.values(TestFailureAction).join(', ')}`,
+      );
+    }
+  }
+}

package/apps/agentcraft/tsconfig.app.json

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

package/apps/agentmanager/README.md

@@ -0,0 +1,141 @@
+# AgentManager
+
+A NestJS backend service for managing a swarm of AI Employees — applications written in the [Agentlang](https://github.com/niclaswebb/agentlang) language. AgentManager provides a RESTful API to register, organize, discover, deploy, and communicate with AI Employees across multiple projects.
+
+## Overview
+
+AgentManager treats AI Employees as first-class resources organized under **projects**. Each employee has Agentlang source code (modules, package manifests, and config), can be deployed to a runtime, and receives messages through an **inbox** system. An LLM-powered **discovery** service lets you find the right employee for a given business need by matching natural-language queries against employee capabilities.
+
+## Architecture
+
+```
+apps/agentmanager/src/
+├── config/             # App configuration (JSON file or env vars)
+├── common/             # Shared filters, interceptors, validators
+├── projects/           # CRUD for project namespaces
+├── employees/          # Register / list / remove AI Employees
+├── employee-code/      # Read / write Agentlang source (modules, package, config)
+├── deployments/        # Query deployment status (local + remote service)
+├── discovery/          # LLM-powered semantic employee lookup
+├── inbox/              # Push messages, list, respond, execute continuations
+└── main.ts             # Fastify bootstrap (port 3001)
+```
+
+### Shared Libraries
+
+- **`@app/project-provider`** — filesystem-backed registry, employee code provider, knowledge base, and inbox client. Provides the storage layer used by all modules.
+
+## API Endpoints
+
+All routes are prefixed with `/api`.
+
+### Projects
+
+| Method | Path | Description |
+|--------|------|-------------|
+| GET | `/api/projects` | List all projects |
+| POST | `/api/projects` | Create a new project |
+| DELETE | `/api/projects/:projectId` | Delete a project |
+
+### Employees
+
+| Method | Path | Description |
+|--------|------|-------------|
+| GET | `/api/projects/:projectId/employees` | List employees in a project |
+| GET | `/api/projects/:projectId/employees/:employeeId` | Get employee details |
+| POST | `/api/projects/:projectId/employees` | Register an employee from source |
+| DELETE | `/api/projects/:projectId/employees/:employeeId` | Remove an employee |
+
+### Employee Code
+
+| Method | Path | Description |
+|--------|------|-------------|
+| GET | `/api/projects/:pid/employees/:eid/modules` | List Agentlang modules |
+| GET | `/api/projects/:pid/employees/:eid/modules/:name` | Get module source |
+| PUT | `/api/projects/:pid/employees/:eid/modules/:name` | Create / update a module |
+| DELETE | `/api/projects/:pid/employees/:eid/modules/:name` | Delete a module |
+| GET | `/api/projects/:pid/employees/:eid/package` | Get package manifest |
+| PUT | `/api/projects/:pid/employees/:eid/package` | Update package manifest |
+| GET | `/api/projects/:pid/employees/:eid/config` | Get employee config |
+| PUT | `/api/projects/:pid/employees/:eid/config` | Update employee config |
+
+### Discovery
+
+| Method | Path | Description |
+|--------|------|-------------|
+| POST | `/api/discover` | Find employees matching a natural-language query |
+
+### Deployments
+
+| Method | Path | Description |
+|--------|------|-------------|
+| GET | `/api/deployments` | List all deployments |
+| GET | `/api/deployments/:projectId/:employeeId` | Get deployment status |
+
+### Inbox
+
+| Method | Path | Description |
+|--------|------|-------------|
+| POST | `/api/inboxes/:inbox/messages` | Push a message |
+| GET | `/api/inboxes/:inbox/messages` | List messages (filter by status/kind/from) |
+| GET | `/api/inboxes/:inbox/messages/:messageId` | Get a single message |
+| POST | `/api/inboxes/:inbox/messages/:messageId/read` | Mark message as read |
+| POST | `/api/inboxes/:inbox/messages/:messageId/respond` | Respond to a message and execute continuation |
+
+## Configuration
+
+Configuration is loaded from a JSON file (default `./config.json`) or environment variables:
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `CONFIG_PATH` | `./config.json` | Path to JSON config file |
+| `PORT` | `3001` | Server port |
+| `REGISTRY_PATH` | `./registry` | Filesystem path for the employee registry |
+| `INBOXES_PATH` | `./inboxes` | Filesystem path for inbox message storage |
+
+### LLM Configuration (for Discovery)
+
+Set via the `llm` key in `config.json`:
+
+```json
+{
+  "llm": {
+    "provider": "anthropic",
+    "model": "claude-sonnet-4-6",
+    "apiKey": "sk-..."
+  }
+}
+```
+
+Supported providers: `anthropic`, `openai`.
+
+### Optional Services
+
+| Config Key | Description |
+|------------|-------------|
+| `agentcraft.baseUrl` | URL of the AgentCraft service (for create suggestions in discovery) |
+| `deploymentService.baseUrl` | URL of an external deployment service for live status |
+
+## Tech Stack
+
+- **Runtime**: Node.js + NestJS with Fastify
+- **Validation**: Zod via `nestjs-zod`
+- **Build**: SWC (fast TypeScript compilation)
+- **Storage**: Filesystem-backed (no database required)
+- **LLM**: Anthropic Claude / OpenAI (optional, for discovery)
+
+## Getting Started
+
+```bash
+# From the monorepo root
+npm install
+npm run build
+
+# Start in development mode
+npm run start:dev
+
+# Start in production mode
+npm run start:prod
+```
+
+The server starts on port **3001** by default.

package/apps/agentmanager/src/agentmanager-core.module.ts

@@ -0,0 +1,45 @@
+import { Module, DynamicModule } from '@nestjs/common';
+import { RouterModule } from '@nestjs/core';
+import { ProjectsModule } from './projects/projects.module';
+import { EmployeesModule } from './employees/employees.module';
+import { EmployeeCodeModule } from './employee-code/employee-code.module';
+import { DiscoveryModule } from './discovery/discovery.module';
+import { DeploymentsModule } from './deployments/deployments.module';
+import { InboxModule } from './inbox/inbox.module';
+import { HealthModule } from './health/health.module';
+
+const AGENTMANAGER_FEATURE_MODULES = [
+  ProjectsModule,
+  EmployeesModule,
+  EmployeeCodeModule,
+  DiscoveryModule,
+  DeploymentsModule,
+  InboxModule,
+  HealthModule,
+];
+
+@Module({})
+export class AgentManagerCoreModule {
+  static forRoot(routePrefix?: string): DynamicModule {
+    const imports: any[] = [...AGENTMANAGER_FEATURE_MODULES];
+    if (routePrefix) {
+      imports.unshift(
+        RouterModule.register([
+          {
+            path: routePrefix,
+            children: AGENTMANAGER_FEATURE_MODULES.map((module) => ({
+              path: '',
+              module,
+            })),
+          },
+        ]),
+      );
+    }
+
+    return {
+      module: AgentManagerCoreModule,
+      imports,
+      exports: [InboxModule],
+    };
+  }
+}

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

@@ -0,0 +1,26 @@
+import { Module } from '@nestjs/common';
+import { APP_FILTER, APP_GUARD, APP_INTERCEPTOR } from '@nestjs/core';
+import { ConfigModule } from '@nestjs/config';
+import { ThrottlerModule, ThrottlerGuard } from '@nestjs/throttler';
+import { ProjectProviderModule } from '@app/project-provider';
+import configuration from './config/configuration';
+import { DomainExceptionFilter, LoggingInterceptor } from '@app/common';
+import { AgentManagerCoreModule } from './agentmanager-core.module';
+
+@Module({
+  imports: [
+    ConfigModule.forRoot({
+      isGlobal: true,
+      load: [configuration],
+    }),
+    ThrottlerModule.forRoot([{ ttl: 60_000, limit: 100 }]),
+    ProjectProviderModule.forRootAsync(),
+    AgentManagerCoreModule.forRoot(),
+  ],
+  providers: [
+    { provide: APP_FILTER, useClass: DomainExceptionFilter },
+    { provide: APP_GUARD, useClass: ThrottlerGuard },
+    { provide: APP_INTERCEPTOR, useClass: LoggingInterceptor },
+  ],
+})
+export class AppModule {}

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

@@ -0,0 +1,63 @@
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { Logger } from '@nestjs/common';
+import { z } from 'zod';
+
+const configSchema = z.object({
+  port: z.number().int().positive(),
+  registryPath: z.string().min(1),
+  inboxesPath: z.string().min(1),
+  llm: z
+    .object({
+      provider: z.enum(['openai', 'anthropic']),
+      model: z.string(),
+      apiKey: z.string(),
+      baseUrl: z.string().optional(),
+    })
+    .optional(),
+  agentcraft: z.object({ baseUrl: z.string() }).optional(),
+  deploymentService: z.object({ baseUrl: z.string() }).optional(),
+  cors: z.object({ origins: z.array(z.string()) }),
+});
+
+export type AppConfiguration = z.infer<typeof configSchema>;
+
+export default (): AppConfiguration => {
+  const logger = new Logger('AgentManagerConfig');
+  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);
+  } catch {
+    // Fall back to defaults / env vars
+  }
+
+  const raw = {
+    port: parsed.port ?? parseInt(process.env.PORT ?? '3001', 10),
+    registryPath:
+      parsed.registryPath ?? process.env.REGISTRY_PATH ?? './registry',
+    inboxesPath: parsed.inboxesPath ?? process.env.INBOXES_PATH ?? './inboxes',
+    llm: parsed.llm ?? undefined,
+    agentcraft: parsed.agentcraft ?? undefined,
+    deploymentService: parsed.deploymentService ?? undefined,
+    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:3000', 'http://127.0.0.1:3000']),
+    },
+  };
+
+  const result = configSchema.safeParse(raw);
+  if (!result.success) {
+    logger.error(`Invalid configuration: ${result.error.message}`);
+    throw new Error(
+      `Invalid AgentManager configuration: ${result.error.message}`,
+    );
+  }
+
+  return result.data;
+};

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

@@ -0,0 +1,21 @@
+import { Controller, Get, Param } from '@nestjs/common';
+import { DeploymentsService } from './deployments.service';
+
+@Controller('deployments')
+export class DeploymentsController {
+  constructor(private readonly deploymentsService: DeploymentsService) {}
+
+  @Get()
+  async listDeployments() {
+    const data = await this.deploymentsService.listDeployments();
+    return { data };
+  }
+
+  @Get(':projectId/:employeeId')
+  async getEmployeeStatus(
+    @Param('projectId') projectId: string,
+    @Param('employeeId') employeeId: string,
+  ) {
+    return this.deploymentsService.getEmployeeStatus(projectId, employeeId);
+  }
+}

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

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+import { DeploymentsController } from './deployments.controller';
+import { DeploymentsService } from './deployments.service';
+
+@Module({
+  controllers: [DeploymentsController],
+  providers: [DeploymentsService],
+  exports: [DeploymentsService],
+})
+export class DeploymentsModule {}