@agentlang/agentmanager 0.0.3

package/apps/integrations/src/api/auth-flow.controller.ts

@@ -0,0 +1,39 @@
+import { Body, Controller, Post } from '@nestjs/common';
+import {
+  CompleteAuthDto,
+  InitiateAuthDto,
+  RefreshAuthDto,
+  RevokeAuthDto,
+  ValidateAuthDto,
+} from '../modules/auth-flow/dto/auth-flow.dto';
+import { AuthFlowService } from '../modules/auth-flow/auth-flow.service';
+
+@Controller('api/auth')
+export class AuthFlowController {
+  public constructor(private readonly authFlow: AuthFlowService) {}
+
+  @Post('initiate')
+  public initiate(@Body() payload: InitiateAuthDto) {
+    return this.authFlow.initiateAuth(payload);
+  }
+
+  @Post('complete')
+  public complete(@Body() payload: CompleteAuthDto) {
+    return this.authFlow.completeAuth(payload);
+  }
+
+  @Post('refresh')
+  public refresh(@Body() payload: RefreshAuthDto) {
+    return this.authFlow.refreshCredentials(payload.connectionId);
+  }
+
+  @Post('revoke')
+  public revoke(@Body() payload: RevokeAuthDto) {
+    return this.authFlow.revokeCredentials(payload.connectionId);
+  }
+
+  @Post('validate')
+  public validate(@Body() payload: ValidateAuthDto) {
+    return this.authFlow.validateCredentials(payload.connectionId);
+  }
+}

package/apps/integrations/src/api/connections.controller.ts

@@ -0,0 +1,26 @@
+import { Controller, Delete, Get, Param, Query } from '@nestjs/common';
+import { ConnectionsService } from '../modules/connections/connections.service';
+
+@Controller('api/connections')
+export class ConnectionsController {
+  public constructor(private readonly connections: ConnectionsService) {}
+
+  @Get()
+  public list(
+    @Query('tenantId') tenantId?: string,
+    @Query('providerId') providerId?: string,
+    @Query('status') status?: string,
+  ) {
+    return this.connections.list({ tenantId, providerId, status });
+  }
+
+  @Get(':id')
+  public getById(@Param('id') id: string) {
+    return this.connections.getById(id);
+  }
+
+  @Delete(':id')
+  public remove(@Param('id') id: string) {
+    return this.connections.remove(id);
+  }
+}

package/apps/integrations/src/api/health.controller.ts

@@ -0,0 +1,34 @@
+import { Controller, Get } from '@nestjs/common';
+import { Public } from '@app/auth';
+import { MetadataStoreService } from '../modules/platform/metadata-store.service';
+
+@Controller()
+export class HealthController {
+  public constructor(private readonly metadataStore: MetadataStoreService) {}
+
+  @Public()
+  @Get('health')
+  public async getHealth() {
+    try {
+      const metadata = await this.metadataStore.health();
+
+      return {
+        status: 'ok',
+        service: 'integrations',
+        timestamp: new Date().toISOString(),
+        dependencies: {
+          metadata,
+        },
+      };
+    } catch {
+      return {
+        status: 'error',
+        service: 'integrations',
+        timestamp: new Date().toISOString(),
+        dependencies: {
+          metadata: { status: 'error' },
+        },
+      };
+    }
+  }
+}

package/apps/integrations/src/api/providers.controller.ts

@@ -0,0 +1,60 @@
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  Param,
+  Post,
+  Put,
+} from '@nestjs/common';
+import { OidcDiscoveryService } from '../modules/discovery/oidc-discovery.service';
+import {
+  CreateProviderDto,
+  DiscoverProviderDto,
+  UpdateProviderDto,
+} from '../modules/providers/dto/provider.dto';
+import { ProviderRegistry } from '../modules/providers/provider.registry';
+import { ProviderDefinitionData } from '../modules/providers/provider.types';
+
+@Controller('api/providers')
+export class ProvidersController {
+  public constructor(
+    private readonly registry: ProviderRegistry,
+    private readonly discoveryService: OidcDiscoveryService,
+  ) {}
+
+  @Get()
+  public list() {
+    return this.registry.getAll().map((p) => p.metadata);
+  }
+
+  @Get(':id')
+  public getById(@Param('id') id: string) {
+    return this.registry.get(id).metadata;
+  }
+
+  @Post()
+  public create(@Body() payload: CreateProviderDto) {
+    return this.registry.createDefinition(
+      payload as unknown as ProviderDefinitionData,
+    );
+  }
+
+  @Put(':id')
+  public update(@Param('id') id: string, @Body() payload: UpdateProviderDto) {
+    return this.registry.updateDefinition(
+      id,
+      payload as unknown as Partial<ProviderDefinitionData>,
+    );
+  }
+
+  @Delete(':id')
+  public remove(@Param('id') id: string) {
+    return this.registry.removeDefinition(id);
+  }
+
+  @Post('discover')
+  public discover(@Body() payload: DiscoverProviderDto) {
+    return this.discoveryService.buildProviderDefinition(payload.issuerUrl);
+  }
+}

package/apps/integrations/src/api/tenant-config.controller.ts

@@ -0,0 +1,62 @@
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  Param,
+  Patch,
+  Put,
+} from '@nestjs/common';
+import {
+  UpdateTenantConfigDto,
+  UpsertTenantConfigDto,
+} from '../modules/tenant-config/dto/tenant-config.dto';
+import { TenantConfigService } from '../modules/tenant-config/tenant-config.service';
+
+@Controller('api/tenants/:tenantId/configs')
+export class TenantConfigController {
+  public constructor(private readonly tenantConfig: TenantConfigService) {}
+
+  @Get()
+  public list(@Param('tenantId') tenantId: string) {
+    return this.tenantConfig.listByTenant(tenantId);
+  }
+
+  @Get(':providerId')
+  public get(
+    @Param('tenantId') tenantId: string,
+    @Param('providerId') providerId: string,
+  ) {
+    return this.tenantConfig.get(tenantId, providerId);
+  }
+
+  @Put(':providerId')
+  public upsert(
+    @Param('tenantId') tenantId: string,
+    @Param('providerId') providerId: string,
+    @Body() payload: UpsertTenantConfigDto,
+  ) {
+    return this.tenantConfig.upsert({
+      tenantId,
+      providerId,
+      ...payload,
+    });
+  }
+
+  @Patch(':providerId')
+  public update(
+    @Param('tenantId') tenantId: string,
+    @Param('providerId') providerId: string,
+    @Body() payload: UpdateTenantConfigDto,
+  ) {
+    return this.tenantConfig.update(tenantId, providerId, payload);
+  }
+
+  @Delete(':providerId')
+  public remove(
+    @Param('tenantId') tenantId: string,
+    @Param('providerId') providerId: string,
+  ) {
+    return this.tenantConfig.remove(tenantId, providerId);
+  }
+}

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

@@ -0,0 +1,38 @@
+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 { AuthModule as SharedAuthModule } from '@app/auth';
+import { DomainExceptionFilter, LoggingInterceptor } from '@app/common';
+import configuration from './config/configuration';
+import { AuthFlowController } from './api/auth-flow.controller';
+import { ConnectionsController } from './api/connections.controller';
+import { HealthController } from './api/health.controller';
+import { ProvidersController } from './api/providers.controller';
+import { TenantConfigController } from './api/tenant-config.controller';
+import { IntegrationsCoreModule } from './integrations-core.module';
+
+@Module({
+  imports: [
+    ConfigModule.forRoot({
+      isGlobal: true,
+      load: [configuration],
+    }),
+    ThrottlerModule.forRoot([{ ttl: 60_000, limit: 100 }]),
+    SharedAuthModule,
+    IntegrationsCoreModule.forRoot(),
+  ],
+  controllers: [
+    HealthController,
+    ProvidersController,
+    AuthFlowController,
+    TenantConfigController,
+    ConnectionsController,
+  ],
+  providers: [
+    { provide: APP_FILTER, useClass: DomainExceptionFilter },
+    { provide: APP_GUARD, useClass: ThrottlerGuard },
+    { provide: APP_INTERCEPTOR, useClass: LoggingInterceptor },
+  ],
+})
+export class AppModule {}

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

@@ -0,0 +1,134 @@
+import { Logger } from '@nestjs/common';
+import { z } from 'zod';
+
+export type StoreType = 'sqlite' | 'postgres';
+
+export interface PostgresConfiguration {
+  url?: string;
+  host?: string;
+  port: number;
+  user?: string;
+  password?: string;
+  database?: string;
+}
+
+export interface AppConfiguration {
+  port: number;
+  authEnabled: boolean;
+  storeType: StoreType;
+  sqlitePath: string;
+  postgres: PostgresConfiguration;
+  encryptionKey: string;
+  httpTimeoutMs: number;
+  httpMaxRetries: number;
+  authStateTtlMs: number;
+  oidcCacheTtlMs: number;
+  defaultListLimit: number;
+  schedulerEnabled: boolean;
+  schedulerIntervalMs: number;
+  shutdownTimeoutMs: number;
+}
+
+const configSchema = z.object({
+  port: z.number().int().positive(),
+  authEnabled: z.boolean(),
+  storeType: z.enum(['sqlite', 'postgres']),
+  sqlitePath: z.string().min(1),
+  postgres: z.object({
+    url: z.string().optional(),
+    host: z.string().optional(),
+    port: z.number().int().positive(),
+    user: z.string().optional(),
+    password: z.string().optional(),
+    database: z.string().optional(),
+  }),
+  encryptionKey: z.string().min(1),
+  httpTimeoutMs: z.number().int().positive(),
+  httpMaxRetries: z.number().int().min(0).max(10),
+  authStateTtlMs: z.number().int().positive(),
+  oidcCacheTtlMs: z.number().int().positive(),
+  defaultListLimit: z.number().int().positive(),
+  schedulerEnabled: z.boolean(),
+  schedulerIntervalMs: z.number().int().positive(),
+  shutdownTimeoutMs: z.number().int().positive(),
+});
+
+const DEV_DEFAULT_KEY = 'default-dev-encryption-key-change-me';
+
+function parseBoolean(raw: string | undefined, fallback: boolean): boolean {
+  if (raw === undefined) {
+    return fallback;
+  }
+
+  return raw === 'true';
+}
+
+function parseInteger(raw: string | undefined, fallback: number): number {
+  if (!raw) {
+    return fallback;
+  }
+
+  const parsed = parseInt(raw, 10);
+  return Number.isNaN(parsed) ? fallback : parsed;
+}
+
+function parseStoreType(raw: string | undefined): StoreType {
+  return raw === 'postgres' ? 'postgres' : 'sqlite';
+}
+
+export default (): AppConfiguration => {
+  const logger = new Logger('IntegrationsConfig');
+
+  const encryptionKey = process.env.ENCRYPTION_KEY ?? DEV_DEFAULT_KEY;
+  const isProduction = process.env.NODE_ENV === 'production';
+
+  if (isProduction && encryptionKey === DEV_DEFAULT_KEY) {
+    throw new Error(
+      'ENCRYPTION_KEY must be set to a non-default value in production',
+    );
+  }
+
+  if (!isProduction && encryptionKey === DEV_DEFAULT_KEY) {
+    logger.warn(
+      'Using default dev encryption key — set ENCRYPTION_KEY for production',
+    );
+  }
+
+  const config = {
+    port: parseInteger(process.env.SERVICE_PORT ?? process.env.PORT, 3006),
+    authEnabled: parseBoolean(process.env.AUTH_ENABLED, true),
+    storeType: parseStoreType(process.env.STORE_TYPE),
+    sqlitePath:
+      process.env.SQLITE_PATH ?? './.integrations/integrations.sqlite',
+    postgres: {
+      url: process.env.POSTGRES_URL,
+      host: process.env.POSTGRES_HOST,
+      port: parseInteger(process.env.POSTGRES_PORT, 5432),
+      user: process.env.POSTGRES_USER,
+      password: process.env.POSTGRES_PASSWORD,
+      database: process.env.POSTGRES_DATABASE,
+    },
+    encryptionKey,
+    httpTimeoutMs: parseInteger(process.env.HTTP_TIMEOUT_MS, 30000),
+    httpMaxRetries: parseInteger(process.env.HTTP_MAX_RETRIES, 3),
+    authStateTtlMs: parseInteger(process.env.AUTH_STATE_TTL_MS, 600000),
+    oidcCacheTtlMs: parseInteger(process.env.OIDC_CACHE_TTL_MS, 3600000),
+    defaultListLimit: parseInteger(process.env.DEFAULT_LIST_LIMIT, 500),
+    schedulerEnabled: parseBoolean(process.env.SCHEDULER_ENABLED, true),
+    schedulerIntervalMs: parseInteger(
+      process.env.SCHEDULER_INTERVAL_MS,
+      300000,
+    ),
+    shutdownTimeoutMs: parseInteger(process.env.SHUTDOWN_TIMEOUT_MS, 5000),
+  };
+
+  const result = configSchema.safeParse(config);
+  if (!result.success) {
+    logger.error(`Invalid configuration: ${result.error.message}`);
+    throw new Error(
+      `Invalid integrations configuration: ${result.error.message}`,
+    );
+  }
+
+  return result.data;
+};

package/apps/integrations/src/generated/prisma-postgres/browser.ts

@@ -0,0 +1,24 @@
+
+/* !!! This is code generated by Prisma. Do not edit directly. !!! */
+/* eslint-disable */
+// biome-ignore-all lint: generated file
+// @ts-nocheck 
+/*
+ * This file should be your main import to use Prisma-related types and utilities in a browser. 
+ * Use it to get access to models, enums, and input types.
+ * 
+ * This file does not contain a `PrismaClient` class, nor several other helpers that are intended as server-side only.
+ * See `client.ts` for the standard, server-side entry point.
+ *
+ * 🟢 You can import this file directly.
+ */
+
+import * as Prisma from './internal/prismaNamespaceBrowser'
+export { Prisma }
+export * as $Enums from './enums'
+export * from './enums';
+/**
+ * Model IntegrationEntity
+ * 
+ */
+export type IntegrationEntity = Prisma.IntegrationEntityModel

package/apps/integrations/src/generated/prisma-postgres/client.ts

@@ -0,0 +1,46 @@
+
+/* !!! This is code generated by Prisma. Do not edit directly. !!! */
+/* eslint-disable */
+// biome-ignore-all lint: generated file
+// @ts-nocheck 
+/*
+ * This file should be your main import to use Prisma. Through it you get access to all the models, enums, and input types.
+ * If you're looking for something you can import in the client-side of your application, please refer to the `browser.ts` file instead.
+ *
+ * 🟢 You can import this file directly.
+ */
+
+import * as process from 'node:process'
+import * as path from 'node:path'
+
+import * as runtime from "@prisma/client/runtime/client"
+import * as $Enums from "./enums"
+import * as $Class from "./internal/class"
+import * as Prisma from "./internal/prismaNamespace"
+
+export * as $Enums from './enums'
+export * from "./enums"
+/**
+ * ## Prisma Client
+ * 
+ * Type-safe database client for TypeScript
+ * @example
+ * ```
+ * const prisma = new PrismaClient({
+ *   adapter: new PrismaPg({ connectionString: process.env.DATABASE_URL })
+ * })
+ * // Fetch zero or more IntegrationEntities
+ * const integrationEntities = await prisma.integrationEntity.findMany()
+ * ```
+ * 
+ * Read more in our [docs](https://pris.ly/d/client).
+ */
+export const PrismaClient = $Class.getPrismaClientClass()
+export type PrismaClient<LogOpts extends Prisma.LogLevel = never, OmitOpts extends Prisma.PrismaClientOptions["omit"] = Prisma.PrismaClientOptions["omit"], ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = $Class.PrismaClient<LogOpts, OmitOpts, ExtArgs>
+export { Prisma }
+
+/**
+ * Model IntegrationEntity
+ * 
+ */
+export type IntegrationEntity = Prisma.IntegrationEntityModel