@agentlang/agentmanager 0.0.3

package/apps/integrations/src/modules/providers/provider.types.ts

@@ -0,0 +1,185 @@
+export enum AuthStrategy {
+  OAuth2 = 'oauth2',
+  OIDC = 'oidc',
+  ApiKey = 'api_key',
+  BasicAuth = 'basic_auth',
+}
+
+export enum ConnectionStatus {
+  Pending = 'pending',
+  Active = 'active',
+  Expired = 'expired',
+  Revoked = 'revoked',
+  Error = 'error',
+}
+
+export interface ScopeDefinition {
+  name: string;
+  description?: string;
+  required?: boolean;
+}
+
+export interface OAuth2Config {
+  authorizeUrl: string;
+  tokenUrl: string;
+  revokeUrl?: string;
+  userinfoUrl?: string;
+  extraAuthorizeParams?: Record<string, string>;
+  tokenResponseMapping?: Record<string, string>;
+  refreshMethod?: 'body' | 'header';
+  usePkce?: boolean;
+}
+
+export interface OidcDiscoveryConfig {
+  issuerUrl: string;
+}
+
+export interface TokenSet {
+  accessToken: string;
+  refreshToken?: string;
+  idToken?: string;
+  tokenType?: string;
+  expiresAt?: number;
+  scope?: string;
+  raw?: Record<string, unknown>;
+}
+
+export interface ProviderMetadata {
+  id: string;
+  name: string;
+  description?: string;
+  icon?: string;
+  category?: string;
+  authStrategy: AuthStrategy;
+  oauth2?: OAuth2Config;
+  oidc?: OidcDiscoveryConfig;
+  defaultScopes?: ScopeDefinition[];
+  builtin?: boolean;
+}
+
+export interface AuthInitiateParams {
+  providerId: string;
+  tenantId: string;
+  connectionId: string;
+  redirectUri: string;
+  scopes?: string[];
+  state?: string;
+  clientId: string;
+  clientSecret: string;
+  codeVerifier?: string;
+}
+
+export interface AuthInitiateResult {
+  authorizeUrl: string;
+  connectionId: string;
+  state: string;
+  codeVerifier?: string;
+}
+
+export interface AuthCompleteParams {
+  providerId: string;
+  tenantId: string;
+  connectionId: string;
+  redirectUri: string;
+  code: string;
+  clientId: string;
+  clientSecret: string;
+  codeVerifier?: string;
+}
+
+export interface AuthCompleteResult {
+  connectionId: string;
+  tokenSet: TokenSet;
+}
+
+export interface IntegrationProvider {
+  readonly metadata: ProviderMetadata;
+  initiateAuth(params: AuthInitiateParams): Promise<AuthInitiateResult>;
+  completeAuth(params: AuthCompleteParams): Promise<AuthCompleteResult>;
+  refreshToken(
+    refreshToken: string,
+    clientId: string,
+    clientSecret: string,
+  ): Promise<TokenSet>;
+  revokeToken(
+    token: string,
+    clientId: string,
+    clientSecret: string,
+  ): Promise<void>;
+}
+
+export interface ProviderDefinitionData {
+  [key: string]: unknown;
+  id: string;
+  name: string;
+  description?: string;
+  icon?: string;
+  category?: string;
+  authStrategy: AuthStrategy;
+  oauth2?: OAuth2Config;
+  oidc?: OidcDiscoveryConfig;
+  defaultScopes?: ScopeDefinition[];
+  createdAt?: string;
+  updatedAt?: string;
+}
+
+export interface TenantProviderConfigData {
+  [key: string]: unknown;
+  id: string;
+  tenantId: string;
+  providerId: string;
+  clientId: string;
+  encryptedClientSecret: string;
+  clientSecretIv: string;
+  clientSecretAuthTag: string;
+  scopes?: string[];
+  enabled: boolean;
+  redirectUri?: string;
+  createdAt?: string;
+  updatedAt?: string;
+}
+
+export interface ConnectionData {
+  [key: string]: unknown;
+  id: string;
+  tenantId: string;
+  providerId: string;
+  userId?: string;
+  status: ConnectionStatus;
+  metadata?: Record<string, unknown>;
+  createdAt?: string;
+  updatedAt?: string;
+}
+
+export interface CredentialData {
+  [key: string]: unknown;
+  id: string;
+  connectionId: string;
+  tenantId: string;
+  providerId: string;
+  encryptedTokenSet: string;
+  iv: string;
+  authTag: string;
+  createdAt?: string;
+  updatedAt?: string;
+}
+
+export interface AuthStateData {
+  [key: string]: unknown;
+  id: string;
+  connectionId: string;
+  tenantId: string;
+  providerId: string;
+  state: string;
+  codeVerifier?: string;
+  redirectUri: string;
+  clientId: string;
+  encryptedClientSecret: string;
+  clientSecretIv: string;
+  clientSecretAuthTag: string;
+  scopes?: string[];
+  expiresAt: string;
+  createdAt?: string;
+}
+
+export const BUILTIN_PROVIDERS = 'BUILTIN_PROVIDERS';

package/apps/integrations/src/modules/providers/providers.module.ts

@@ -0,0 +1,34 @@
+import { Module } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { DiscoveryModule } from '../discovery/discovery.module';
+import { PlatformModule } from '../platform/platform.module';
+import { createGoogleDriveProvider } from './builtin/google-drive.provider';
+import { ProviderFactory } from './provider.factory';
+import { ProviderRegistry } from './provider.registry';
+import { BUILTIN_PROVIDERS } from './provider.types';
+import { AppConfiguration } from '../../config/configuration';
+
+@Module({
+  imports: [PlatformModule, DiscoveryModule],
+  providers: [
+    ProviderFactory,
+    ProviderRegistry,
+    {
+      provide: BUILTIN_PROVIDERS,
+      useFactory: (configService: ConfigService<AppConfiguration>) => {
+        const fetchOptions = {
+          timeoutMs: configService.get<number>('httpTimeoutMs', {
+            infer: true,
+          }),
+          maxRetries: configService.get<number>('httpMaxRetries', {
+            infer: true,
+          }),
+        };
+        return [createGoogleDriveProvider(fetchOptions)];
+      },
+      inject: [ConfigService],
+    },
+  ],
+  exports: [ProviderRegistry, ProviderFactory],
+})
+export class ProvidersModule {}

package/apps/integrations/src/modules/tenant-config/dto/tenant-config.dto.ts

@@ -0,0 +1,28 @@
+import { createZodDto } from 'nestjs-zod';
+import { z } from 'zod';
+
+export const UpsertTenantConfigSchema = z.object({
+  clientId: z.string().min(1),
+  clientSecret: z.string().min(1),
+  scopes: z.array(z.string()).optional(),
+  enabled: z.boolean().optional(),
+  redirectUri: z.string().url().optional(),
+});
+
+export const UpdateTenantConfigSchema = z.object({
+  clientId: z.string().min(1).optional(),
+  clientSecret: z.string().min(1).optional(),
+  scopes: z.array(z.string()).optional(),
+  enabled: z.boolean().optional(),
+  redirectUri: z.string().url().optional(),
+});
+
+export class UpsertTenantConfigDto extends createZodDto(
+  UpsertTenantConfigSchema,
+) {}
+export class UpdateTenantConfigDto extends createZodDto(
+  UpdateTenantConfigSchema,
+) {}
+
+export type UpsertTenantConfigInput = z.infer<typeof UpsertTenantConfigSchema>;
+export type UpdateTenantConfigInput = z.infer<typeof UpdateTenantConfigSchema>;

package/apps/integrations/src/modules/tenant-config/tenant-config.module.ts

@@ -0,0 +1,11 @@
+import { Module } from '@nestjs/common';
+import { CredentialsModule } from '../credentials/credentials.module';
+import { PlatformModule } from '../platform/platform.module';
+import { TenantConfigService } from './tenant-config.service';
+
+@Module({
+  imports: [PlatformModule, CredentialsModule],
+  providers: [TenantConfigService],
+  exports: [TenantConfigService],
+})
+export class TenantConfigModule {}

package/apps/integrations/src/modules/tenant-config/tenant-config.service.ts

@@ -0,0 +1,212 @@
+import { Injectable, Logger, NotFoundException } from '@nestjs/common';
+import { EncryptionService } from '../credentials/encryption.service';
+import { MetadataStoreService } from '../platform/metadata-store.service';
+import {
+  ScopeDefinition,
+  TenantProviderConfigData,
+} from '../providers/provider.types';
+
+export interface CreateTenantConfigInput {
+  tenantId: string;
+  providerId: string;
+  clientId: string;
+  clientSecret: string;
+  scopes?: string[];
+  enabled?: boolean;
+  redirectUri?: string;
+}
+
+export interface UpdateTenantConfigInput {
+  clientId?: string;
+  clientSecret?: string;
+  scopes?: string[];
+  enabled?: boolean;
+  redirectUri?: string;
+}
+
+export interface TenantConfigPublic {
+  id: string;
+  tenantId: string;
+  providerId: string;
+  clientId: string;
+  scopes?: string[];
+  enabled: boolean;
+  redirectUri?: string;
+  createdAt?: string;
+  updatedAt?: string;
+}
+
+@Injectable()
+export class TenantConfigService {
+  private readonly logger = new Logger(TenantConfigService.name);
+
+  public constructor(
+    private readonly metadataStore: MetadataStoreService,
+    private readonly encryption: EncryptionService,
+  ) {}
+
+  private compositeId(tenantId: string, providerId: string): string {
+    return `${tenantId}:${providerId}`;
+  }
+
+  public async get(
+    tenantId: string,
+    providerId: string,
+  ): Promise<TenantConfigPublic> {
+    const id = this.compositeId(tenantId, providerId);
+    const record = await this.metadataStore.getById('TenantConfig', id);
+    if (!record) {
+      throw new NotFoundException(
+        `Config for tenant=${tenantId} provider=${providerId} not found`,
+      );
+    }
+
+    return this.toPublic(record as unknown as TenantProviderConfigData);
+  }
+
+  public async listByTenant(tenantId: string): Promise<TenantConfigPublic[]> {
+    const records = await this.metadataStore.list('TenantConfig', {
+      filters: { tenantId },
+    });
+
+    return records.map((r) =>
+      this.toPublic(r as unknown as TenantProviderConfigData),
+    );
+  }
+
+  public async upsert(
+    input: CreateTenantConfigInput,
+  ): Promise<TenantConfigPublic> {
+    this.logger.debug(
+      `Upserting config for tenant=${input.tenantId} provider=${input.providerId}`,
+    );
+    const id = this.compositeId(input.tenantId, input.providerId);
+    const now = new Date().toISOString();
+
+    const encrypted = this.encryption.encrypt(input.clientSecret);
+
+    const record: TenantProviderConfigData = {
+      id,
+      tenantId: input.tenantId,
+      providerId: input.providerId,
+      clientId: input.clientId,
+      encryptedClientSecret: encrypted.ciphertext,
+      clientSecretIv: encrypted.iv,
+      clientSecretAuthTag: encrypted.authTag,
+      scopes: input.scopes,
+      enabled: input.enabled ?? true,
+      redirectUri: input.redirectUri,
+      createdAt: now,
+      updatedAt: now,
+    };
+
+    await this.metadataStore.upsert('TenantConfig', record);
+
+    return this.toPublic(record);
+  }
+
+  public async update(
+    tenantId: string,
+    providerId: string,
+    input: UpdateTenantConfigInput,
+  ): Promise<TenantConfigPublic> {
+    this.logger.debug(
+      `Updating config for tenant=${tenantId} provider=${providerId}`,
+    );
+    const id = this.compositeId(tenantId, providerId);
+    const existing = await this.metadataStore.getById('TenantConfig', id);
+    if (!existing) {
+      throw new NotFoundException(
+        `Config for tenant=${tenantId} provider=${providerId} not found`,
+      );
+    }
+
+    const current = existing as unknown as TenantProviderConfigData;
+    const now = new Date().toISOString();
+
+    const updated: TenantProviderConfigData = {
+      ...current,
+      clientId: input.clientId ?? current.clientId,
+      scopes: input.scopes ?? current.scopes,
+      enabled: input.enabled ?? current.enabled,
+      redirectUri: input.redirectUri ?? current.redirectUri,
+      updatedAt: now,
+    };
+
+    if (input.clientSecret) {
+      const encrypted = this.encryption.encrypt(input.clientSecret);
+      updated.encryptedClientSecret = encrypted.ciphertext;
+      updated.clientSecretIv = encrypted.iv;
+      updated.clientSecretAuthTag = encrypted.authTag;
+    }
+
+    await this.metadataStore.upsert('TenantConfig', updated);
+
+    return this.toPublic(updated);
+  }
+
+  public async remove(
+    tenantId: string,
+    providerId: string,
+  ): Promise<{ success: boolean }> {
+    this.logger.debug(
+      `Removing config for tenant=${tenantId} provider=${providerId}`,
+    );
+    const id = this.compositeId(tenantId, providerId);
+    const deleted = await this.metadataStore.remove('TenantConfig', id);
+    return { success: deleted };
+  }
+
+  public decryptClientSecret(config: TenantProviderConfigData): string {
+    return this.encryption.decrypt(
+      config.encryptedClientSecret,
+      config.clientSecretIv,
+      config.clientSecretAuthTag,
+    );
+  }
+
+  public async getFullConfig(
+    tenantId: string,
+    providerId: string,
+  ): Promise<TenantProviderConfigData> {
+    const id = this.compositeId(tenantId, providerId);
+    const record = await this.metadataStore.getById('TenantConfig', id);
+    if (!record) {
+      throw new NotFoundException(
+        `Config for tenant=${tenantId} provider=${providerId} not found`,
+      );
+    }
+
+    return record as unknown as TenantProviderConfigData;
+  }
+
+  public resolveScopes(
+    callerScopes?: string[],
+    tenantScopes?: string[],
+    providerDefaults?: ScopeDefinition[],
+  ): string[] {
+    if (callerScopes && callerScopes.length > 0) {
+      return callerScopes;
+    }
+
+    if (tenantScopes && tenantScopes.length > 0) {
+      return tenantScopes;
+    }
+
+    return providerDefaults?.map((s) => s.name) ?? [];
+  }
+
+  private toPublic(record: TenantProviderConfigData): TenantConfigPublic {
+    return {
+      id: record.id,
+      tenantId: record.tenantId,
+      providerId: record.providerId,
+      clientId: record.clientId,
+      scopes: record.scopes,
+      enabled: record.enabled,
+      redirectUri: record.redirectUri,
+      createdAt: record.createdAt,
+      updatedAt: record.updatedAt,
+    };
+  }
+}

package/apps/integrations/tsconfig.app.json

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

package/apps/knowledge/prisma/prisma.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig, env } from 'prisma/config';
+
+export default defineConfig({
+  schema: './schema.postgres.prisma',
+  datasource: {
+    url: env('KNOWLEDGE_DATABASE_URL_POSTGRES'),
+  },
+});

package/apps/knowledge/prisma/schema.postgres.prisma

@@ -0,0 +1,29 @@
+generator client {
+  provider = "prisma-client"
+  output   = "../src/generated/prisma-postgres"
+}
+
+datasource db {
+  provider = "postgresql"
+}
+
+model KnowledgeEntity {
+  entity            String
+  id                String
+  topicId           String?
+  connectionId      String?
+  documentId        String?
+  documentVersionId String?
+  status            String?
+  data              Json
+  createdAt         DateTime @default(now())
+  updatedAt         DateTime @updatedAt
+
+  @@id([entity, id])
+  @@index([entity])
+  @@index([entity, topicId])
+  @@index([entity, connectionId])
+  @@index([entity, documentId])
+  @@index([entity, documentVersionId])
+  @@index([entity, status])
+}

package/apps/knowledge/prisma/schema.sqlite.prisma

@@ -0,0 +1,29 @@
+generator client {
+  provider = "prisma-client"
+  output   = "../src/generated/prisma-sqlite"
+}
+
+datasource db {
+  provider = "sqlite"
+}
+
+model KnowledgeEntity {
+  entity            String
+  id                String
+  topicId           String?
+  connectionId      String?
+  documentId        String?
+  documentVersionId String?
+  status            String?
+  data              Json
+  createdAt         DateTime @default(now())
+  updatedAt         DateTime @updatedAt
+
+  @@id([entity, id])
+  @@index([entity])
+  @@index([entity, topicId])
+  @@index([entity, connectionId])
+  @@index([entity, documentId])
+  @@index([entity, documentVersionId])
+  @@index([entity, status])
+}

package/apps/knowledge/scripts/prepare-db.cjs

@@ -0,0 +1,72 @@
+const { spawnSync } = require('node:child_process');
+
+function asStoreType(raw) {
+  return raw === 'postgres' ? 'postgres' : 'sqlite';
+}
+
+function buildPostgresUrl(env) {
+  if (env.KNOWLEDGE_DATABASE_URL_POSTGRES) {
+    return env.KNOWLEDGE_DATABASE_URL_POSTGRES;
+  }
+
+  if (env.POSTGRES_URL) {
+    return env.POSTGRES_URL;
+  }
+
+  const user = env.POSTGRES_USER || 'postgres';
+  const password = env.POSTGRES_PASSWORD || '';
+  const host = env.POSTGRES_HOST || 'localhost';
+  const port = env.POSTGRES_PORT || '5432';
+  const database = env.POSTGRES_DATABASE || 'knowledge';
+
+  const encodedUser = encodeURIComponent(user);
+  const encodedPassword = password ? `:${encodeURIComponent(password)}` : '';
+
+  return `postgresql://${encodedUser}${encodedPassword}@${host}:${port}/${database}`;
+}
+
+function buildSqliteUrl(env) {
+  if (env.KNOWLEDGE_DATABASE_URL_SQLITE) {
+    return env.KNOWLEDGE_DATABASE_URL_SQLITE;
+  }
+
+  const sqlitePath = env.SQLITE_PATH || './.knowledge/knowledge.sqlite';
+  return sqlitePath.startsWith('file:') ? sqlitePath : `file:${sqlitePath}`;
+}
+
+function run() {
+  const storeType = asStoreType(process.env.STORE_TYPE);
+  const env = { ...process.env };
+
+  if (storeType === 'postgres') {
+    env.KNOWLEDGE_DATABASE_URL_POSTGRES = buildPostgresUrl(env);
+  } else {
+    env.KNOWLEDGE_DATABASE_URL_SQLITE = buildSqliteUrl(env);
+  }
+
+  const postgresArgs = [
+    'prisma',
+    'db',
+    'push',
+    '--config',
+    'apps/knowledge/prisma/prisma.config.ts',
+  ];
+  const sqliteArgs = [
+    'prisma',
+    'db',
+    'push',
+    '--schema',
+    'apps/knowledge/prisma/schema.sqlite.prisma',
+  ];
+
+  const pushed = spawnSync('npx', storeType === 'postgres' ? postgresArgs : sqliteArgs, {
+    env,
+    stdio: 'inherit',
+  });
+
+  if (pushed.status !== 0) {
+    process.exit(pushed.status || 1);
+  }
+}
+
+run();

package/apps/knowledge/src/api/auth.controller.ts

@@ -0,0 +1,54 @@
+import { Body, Controller, Post } from '@nestjs/common';
+import { createZodDto } from 'nestjs-zod';
+import { z } from 'zod';
+import { Public } from '@app/auth';
+import { AuthService } from '../modules/auth/auth.service';
+
+const LoginSchema = z.object({
+  username: z.string().optional(),
+  email: z.string().email().optional(),
+  password: z.string(),
+});
+
+const RefreshTokenSchema = z.object({
+  refreshToken: z.string(),
+  refresh_token: z.string().optional(),
+  username: z.string().optional(),
+  email: z.string().optional(),
+});
+
+const AssignRoleSchema = z.object({
+  email: z.string().email(),
+  role: z.string().optional(),
+  group: z.string().optional(),
+});
+
+class LoginDto extends createZodDto(LoginSchema) {}
+class RefreshTokenDto extends createZodDto(RefreshTokenSchema) {}
+class AssignRoleDto extends createZodDto(AssignRoleSchema) {}
+
+@Controller('api/auth')
+export class AuthController {
+  public constructor(private readonly authService: AuthService) {}
+
+  @Public()
+  @Post('login')
+  public login(@Body() body: LoginDto) {
+    return this.authService.login(body as unknown as Record<string, unknown>);
+  }
+
+  @Public()
+  @Post('refresh')
+  public refreshToken(@Body() body: RefreshTokenDto) {
+    return this.authService.refreshToken(
+      body as unknown as Record<string, unknown>,
+    );
+  }
+
+  @Post('assign-role')
+  public assignUserToRoleByEmail(@Body() body: AssignRoleDto) {
+    return this.authService.assignUserToRoleByEmail(
+      body as unknown as Record<string, unknown>,
+    );
+  }
+}