@codemation/host 0.0.5 → 0.0.7

package/src/bootstrap/runtime/AppConfigFactory.ts

@@ -1,57 +1,182 @@
+import { CoreTokens } from "@codemation/core";
 import type { AppConfig } from "../../presentation/config/AppConfig";
-import type { CodemationAuthConfig } from "../../presentation/config/CodemationAuthConfig";
-import type { CodemationApplicationRuntimeConfig } from "../../presentation/config/CodemationConfig";
-import type { CodemationWhitelabelConfig } from "../../presentation/config/CodemationWhitelabelConfig";
-import { ResolvedImplementationSelectionFactory } from "./ResolvedImplementationSelectionFactory";
+import type { NormalizedCodemationConfig } from "../../presentation/config/CodemationConfigNormalizer";
+import type {
+  CodemationApplicationRuntimeConfig,
+  CodemationDatabaseKind,
+  CodemationEventBusKind,
+  CodemationSchedulerKind,
+} from "../../presentation/config/CodemationConfig";
+import path from "node:path";
 
 export class AppConfigFactory {
-  constructor(
-    private readonly implementationSelectionFactory: ResolvedImplementationSelectionFactory = new ResolvedImplementationSelectionFactory(),
-  ) {}
-
   create(
     args: Readonly<{
       repoRoot: string;
       consumerRoot: string;
       env: NodeJS.ProcessEnv;
+      config: NormalizedCodemationConfig;
       workflowSources: ReadonlyArray<string>;
-      runtimeConfig: CodemationApplicationRuntimeConfig;
-      authConfig: CodemationAuthConfig | undefined;
-      whitelabelConfig: CodemationWhitelabelConfig;
     }>,
   ): AppConfig {
-    const selection = this.implementationSelectionFactory.resolve({
-      consumerRoot: args.consumerRoot,
-      env: args.env,
-      runtimeConfig: args.runtimeConfig,
-    });
-    const workerQueues = args.runtimeConfig.scheduler?.workerQueues ?? [];
-    const queuePrefix = args.runtimeConfig.scheduler?.queuePrefix ?? args.runtimeConfig.eventBus?.queuePrefix;
-    const databaseUrl =
-      selection.databasePersistence.kind === "postgresql"
-        ? selection.databasePersistence.databaseUrl
-        : args.runtimeConfig.database?.url?.trim() || undefined;
+    const runtimeConfig = args.config.runtime ?? {};
+    const persistence = this.resolvePersistence(runtimeConfig, args.env, args.consumerRoot);
+    const redisUrl = runtimeConfig.eventBus?.redisUrl ?? args.env.REDIS_URL;
+    const schedulerKind = this.resolveSchedulerKind(runtimeConfig, args.env, redisUrl);
+    const eventBusKind = this.resolveEventBusKind(runtimeConfig, args.env, schedulerKind, redisUrl);
+    const workerQueues = runtimeConfig.scheduler?.workerQueues ?? [];
+    const queuePrefix =
+      runtimeConfig.scheduler?.queuePrefix ?? runtimeConfig.eventBus?.queuePrefix ?? args.env.QUEUE_PREFIX;
+    const hasConfiguredCredentialSessionServiceRegistration = args.config.containerRegistrations.some(
+      (entry) => entry.token === CoreTokens.CredentialSessionService,
+    );
 
     return {
       consumerRoot: args.consumerRoot,
       repoRoot: args.repoRoot,
       env: args.env,
       workflowSources: [...args.workflowSources],
-      databaseUrl,
-      database: args.runtimeConfig.database,
+      workflows: [...(args.config.workflows ?? [])],
+      containerRegistrations: [...args.config.containerRegistrations],
+      credentialTypes: [...(args.config.credentialTypes ?? [])],
+      plugins: [...(args.config.plugins ?? [])],
+      hasConfiguredCredentialSessionServiceRegistration,
+      log: args.config.log,
+      engineExecutionLimits: runtimeConfig.engineExecutionLimits,
+      databaseUrl:
+        persistence.kind === "postgresql" ? persistence.databaseUrl : runtimeConfig.database?.url?.trim() || undefined,
+      database: runtimeConfig.database,
+      persistence,
       scheduler: {
-        kind: selection.schedulerKind,
+        kind: schedulerKind,
         queuePrefix,
         workerQueues,
-        redisUrl: selection.redisUrl,
+        redisUrl,
       },
       eventing: {
-        kind: selection.eventBusKind,
+        kind: eventBusKind,
         queuePrefix,
-        redisUrl: selection.redisUrl,
+        redisUrl,
       },
-      auth: args.authConfig,
-      whitelabel: args.whitelabelConfig,
+      auth: args.config.auth,
+      whitelabel: args.config.whitelabel ?? {},
+      webSocketPort: this.resolveWebSocketPort(args.env),
+      webSocketBindHost: args.env.CODEMATION_WS_BIND_HOST ?? "0.0.0.0",
     };
   }
+
+  private resolvePersistence(
+    runtimeConfig: CodemationApplicationRuntimeConfig,
+    env: NodeJS.ProcessEnv,
+    consumerRoot: string,
+  ): AppConfig["persistence"] {
+    const database = runtimeConfig.database;
+    if (!database) {
+      return { kind: "none" };
+    }
+    const kind = this.resolveDatabaseKind(database.kind, database.url, env);
+    if (kind === "postgresql") {
+      const databaseUrl = database.url?.trim() ?? "";
+      if (!databaseUrl) {
+        throw new Error('runtime.database.kind is "postgresql" but no database URL was set (runtime.database.url).');
+      }
+      if (!databaseUrl.startsWith("postgresql://") && !databaseUrl.startsWith("postgres://")) {
+        throw new Error(
+          `runtime.database.url must be a postgresql:// or postgres:// URL when kind is postgresql. Received: ${databaseUrl}`,
+        );
+      }
+      return { kind: "postgresql", databaseUrl };
+    }
+    return {
+      kind: "pglite",
+      dataDir: this.resolvePgliteDataDir(database.pgliteDataDir, env, consumerRoot),
+    };
+  }
+
+  private resolveDatabaseKind(
+    configuredKind: CodemationDatabaseKind | undefined,
+    databaseUrl: string | undefined,
+    env: NodeJS.ProcessEnv,
+  ): CodemationDatabaseKind {
+    const kindFromEnv = env.CODEMATION_DATABASE_KIND?.trim();
+    if (kindFromEnv === "postgresql" || kindFromEnv === "pglite") {
+      return kindFromEnv;
+    }
+    if (configuredKind) {
+      return configuredKind;
+    }
+    const trimmedUrl = databaseUrl?.trim();
+    if (trimmedUrl && (trimmedUrl.startsWith("postgresql://") || trimmedUrl.startsWith("postgres://"))) {
+      return "postgresql";
+    }
+    return "pglite";
+  }
+
+  private resolvePgliteDataDir(
+    configuredPath: string | undefined,
+    env: NodeJS.ProcessEnv,
+    consumerRoot: string,
+  ): string {
+    const envPath = env.CODEMATION_PGLITE_DATA_DIR?.trim();
+    if (envPath && envPath.length > 0) {
+      return path.isAbsolute(envPath) ? envPath : path.resolve(consumerRoot, envPath);
+    }
+    const trimmedConfiguredPath = configuredPath?.trim();
+    if (trimmedConfiguredPath && trimmedConfiguredPath.length > 0) {
+      return path.isAbsolute(trimmedConfiguredPath)
+        ? trimmedConfiguredPath
+        : path.resolve(consumerRoot, trimmedConfiguredPath);
+    }
+    return path.resolve(consumerRoot, ".codemation", "pglite");
+  }
+
+  private resolveSchedulerKind(
+    runtimeConfig: CodemationApplicationRuntimeConfig,
+    env: NodeJS.ProcessEnv,
+    redisUrl: string | undefined,
+  ): CodemationSchedulerKind {
+    const configuredKind = runtimeConfig.scheduler?.kind ?? this.readSchedulerKind(env.CODEMATION_SCHEDULER);
+    if (configuredKind) {
+      return configuredKind;
+    }
+    return redisUrl ? "bullmq" : "local";
+  }
+
+  private resolveEventBusKind(
+    runtimeConfig: CodemationApplicationRuntimeConfig,
+    env: NodeJS.ProcessEnv,
+    schedulerKind: CodemationSchedulerKind,
+    redisUrl: string | undefined,
+  ): CodemationEventBusKind {
+    const configuredKind = runtimeConfig.eventBus?.kind ?? this.readEventBusKind(env.CODEMATION_EVENT_BUS);
+    if (configuredKind) {
+      return configuredKind;
+    }
+    if (schedulerKind === "bullmq") {
+      return "redis";
+    }
+    return redisUrl ? "redis" : "memory";
+  }
+
+  private readSchedulerKind(value: string | undefined): CodemationSchedulerKind | undefined {
+    if (value === "local" || value === "bullmq") {
+      return value;
+    }
+    return undefined;
+  }
+
+  private readEventBusKind(value: string | undefined): CodemationEventBusKind | undefined {
+    if (value === "memory" || value === "redis") {
+      return value;
+    }
+    return undefined;
+  }
+
+  private resolveWebSocketPort(env: NodeJS.ProcessEnv): number {
+    const configuredPort = Number(env.CODEMATION_WS_PORT ?? 3001);
+    if (Number.isNaN(configuredPort) || configuredPort <= 0) {
+      return 3001;
+    }
+    return configuredPort;
+  }
 }

package/src/bootstrap/runtime/DatabaseMigrations.ts

@@ -0,0 +1,18 @@
+import { inject, injectable } from "@codemation/core";
+import { ApplicationTokens } from "../../applicationTokens";
+import type { AppConfig } from "../../presentation/config/AppConfig";
+import { PrismaMigrationDeployer } from "../../infrastructure/persistence/PrismaMigrationDeployer";
+
+@injectable()
+export class DatabaseMigrations {
+  constructor(
+    @inject(ApplicationTokens.AppConfig)
+    private readonly appConfig: AppConfig,
+    @inject(PrismaMigrationDeployer)
+    private readonly prismaMigrationDeployer: PrismaMigrationDeployer,
+  ) {}
+
+  async migrate(): Promise<void> {
+    await this.prismaMigrationDeployer.deployPersistence(this.appConfig.persistence, this.appConfig.env);
+  }
+}

package/src/bootstrap/runtime/FrontendRuntime.ts

@@ -0,0 +1,44 @@
+import { CoreTokens, inject, injectable, type WorkflowRepository } from "@codemation/core";
+import { Engine } from "@codemation/core/bootstrap";
+import { ApplicationTokens } from "../../applicationTokens";
+import type { AppConfig } from "../../presentation/config/AppConfig";
+import { RuntimeWorkflowActivationPolicy } from "../../infrastructure/persistence/RuntimeWorkflowActivationPolicy";
+import { WorkflowRunEventWebsocketRelay } from "../../application/websocket/WorkflowRunEventWebsocketRelay";
+import { WorkflowWebsocketServer } from "../../presentation/websocket/WorkflowWebsocketServer";
+import { DatabaseMigrations } from "./DatabaseMigrations";
+import type { WorkflowActivationRepository } from "../../domain/workflows/WorkflowActivationRepository";
+
+@injectable()
+export class FrontendRuntime {
+  constructor(
+    @inject(ApplicationTokens.AppConfig)
+    private readonly appConfig: AppConfig,
+    @inject(DatabaseMigrations)
+    private readonly databaseMigrations: DatabaseMigrations,
+    @inject(RuntimeWorkflowActivationPolicy)
+    private readonly runtimeWorkflowActivationPolicy: RuntimeWorkflowActivationPolicy,
+    @inject(ApplicationTokens.WorkflowActivationRepository)
+    private readonly workflowActivationRepository: WorkflowActivationRepository,
+    @inject(CoreTokens.WorkflowRepository)
+    private readonly workflowRepository: WorkflowRepository,
+    @inject(WorkflowWebsocketServer)
+    private readonly workflowWebsocketServer: WorkflowWebsocketServer,
+    @inject(WorkflowRunEventWebsocketRelay)
+    private readonly workflowRunEventWebsocketRelay: WorkflowRunEventWebsocketRelay,
+    @inject(Engine)
+    private readonly engine: Engine,
+  ) {}
+
+  async start(args?: Readonly<{ skipPresentationServers?: boolean }>): Promise<void> {
+    if (this.appConfig.env.CODEMATION_SKIP_STARTUP_MIGRATIONS !== "true") {
+      await this.databaseMigrations.migrate();
+    }
+    await this.runtimeWorkflowActivationPolicy.hydrateFromRepository(this.workflowActivationRepository);
+    if (args?.skipPresentationServers === true) {
+      return;
+    }
+    await this.engine.start([...this.workflowRepository.list()]);
+    await this.workflowWebsocketServer.start();
+    await this.workflowRunEventWebsocketRelay.start();
+  }
+}

package/src/bootstrap/runtime/WorkerRuntime.ts

@@ -0,0 +1,55 @@
+import type { WorkflowRepository } from "@codemation/core";
+import { CoreTokens, inject, injectable } from "@codemation/core";
+import { Engine } from "@codemation/core/bootstrap";
+import { ApplicationTokens } from "../../applicationTokens";
+import type { AppConfig } from "../../presentation/config/AppConfig";
+import type {
+  WorkerRuntimeHandle,
+  WorkerRuntimeScheduler,
+} from "../../infrastructure/scheduler/WorkerRuntimeScheduler";
+import { RuntimeWorkflowActivationPolicy } from "../../infrastructure/persistence/RuntimeWorkflowActivationPolicy";
+import type { WorkflowActivationRepository } from "../../domain/workflows/WorkflowActivationRepository";
+import { DatabaseMigrations } from "./DatabaseMigrations";
+import { AppContainerLifecycle } from "../AppContainerLifecycle";
+
+@injectable()
+export class WorkerRuntime {
+  constructor(
+    @inject(ApplicationTokens.AppConfig)
+    private readonly appConfig: AppConfig,
+    @inject(DatabaseMigrations)
+    private readonly databaseMigrations: DatabaseMigrations,
+    @inject(RuntimeWorkflowActivationPolicy)
+    private readonly runtimeWorkflowActivationPolicy: RuntimeWorkflowActivationPolicy,
+    @inject(ApplicationTokens.WorkflowActivationRepository)
+    private readonly workflowActivationRepository: WorkflowActivationRepository,
+    @inject(CoreTokens.WorkflowRepository)
+    private readonly workflowRepository: WorkflowRepository,
+    @inject(Engine)
+    private readonly engine: Engine,
+    @inject(ApplicationTokens.WorkerRuntimeScheduler)
+    private readonly scheduler: WorkerRuntimeScheduler,
+    @inject(AppContainerLifecycle)
+    private readonly lifecycle: AppContainerLifecycle,
+  ) {}
+
+  async start(queues: ReadonlyArray<string>): Promise<WorkerRuntimeHandle> {
+    if (this.appConfig.env.CODEMATION_SKIP_STARTUP_MIGRATIONS !== "true") {
+      await this.databaseMigrations.migrate();
+    }
+    await this.runtimeWorkflowActivationPolicy.hydrateFromRepository(this.workflowActivationRepository);
+    const workflows = [...this.workflowRepository.list()];
+    await this.engine.start(workflows);
+    const worker = this.scheduler.createWorker({
+      queues,
+      requestHandler: this.engine,
+    });
+    return {
+      stop: async () => {
+        await worker.stop();
+        await this.scheduler.close();
+        await this.lifecycle.stop({ stopWebsocketServer: false });
+      },
+    };
+  }
+}

package/src/client.ts

@@ -1,3 +1,10 @@
 export type { Logger, LoggerFactory } from "./application/logging/Logger";
 export { BrowserLoggerFactory } from "./infrastructure/logging/BrowserLoggerFactory";
 export type { CodemationWhitelabelConfig } from "./presentation/config/CodemationWhitelabelConfig";
+export type { FrontendAppConfig } from "./presentation/frontend/FrontendAppConfig";
+export type {
+  CodemationFrontendAuthProviderSnapshot,
+  CodemationFrontendAuthSnapshot,
+} from "./presentation/frontend/CodemationFrontendAuthSnapshot";
+export { CodemationFrontendAuthSnapshotJsonCodec } from "./presentation/frontend/CodemationFrontendAuthSnapshotJsonCodec";
+export { FrontendAppConfigJsonCodec } from "./presentation/frontend/FrontendAppConfigJsonCodec";

package/src/index.ts

@@ -3,15 +3,16 @@ export type { QueryBus } from "./application/bus/QueryBus";
 export { ListUserAccountsQuery } from "./application/queries/ListUserAccountsQuery";
 export { UpsertLocalBootstrapUserCommand } from "./application/commands/UpsertLocalBootstrapUserCommand";
 export type { UpsertLocalBootstrapUserResultDto } from "./application/contracts/userDirectoryContracts.types";
-export { CodemationApplication } from "./codemationApplication";
-export type { CodemationApplicationConfig, CodemationStopHandle } from "./codemationApplication";
+export { AppContainerFactory } from "./bootstrap/AppContainerFactory";
+export { AppContainerLifecycle } from "./bootstrap/AppContainerLifecycle";
+export { DatabaseMigrations } from "./bootstrap/runtime/DatabaseMigrations";
+export { FrontendRuntime } from "./bootstrap/runtime/FrontendRuntime";
+export { WorkerRuntime } from "./bootstrap/runtime/WorkerRuntime";
+export { AppConfigFactory } from "./bootstrap/runtime/AppConfigFactory";
 export { ApplicationTokens } from "./applicationTokens";
 export { CodemationBootstrapRequest } from "./bootstrap/CodemationBootstrapRequest";
-export { CodemationFrontendBootstrapRequest } from "./bootstrap/CodemationFrontendBootstrapRequest";
-export { CodemationWorkerBootstrapRequest } from "./bootstrap/CodemationWorkerBootstrapRequest";
 export type { CodemationWhitelabelConfig } from "./presentation/config/CodemationWhitelabelConfig";
 export type { AppConfig } from "./presentation/config/AppConfig";
-export type { CodemationApplicationFacade } from "./presentation/config/CodemationApplicationFacade";
 export type {
   CodemationAuthConfig,
   CodemationAuthKind,
@@ -37,6 +38,11 @@ export type {
   CodemationAppContext,
   CodemationRegistrationContextBase,
 } from "./presentation/config/CodemationAppContext";
+export type {
+  CodemationFrontendAuthProviderSnapshot,
+  CodemationFrontendAuthSnapshot,
+} from "./presentation/frontend/CodemationFrontendAuthSnapshot";
+export type { FrontendAppConfig } from "./presentation/frontend/FrontendAppConfig";
 export type {
   CodemationLogConfig,
   CodemationLogLevelName,
@@ -51,6 +57,10 @@ export { CodemationPluginListMerger } from "./presentation/config/CodemationPlug
 export type { CodemationWorkflowDiscovery } from "./presentation/config/CodemationWorkflowDiscovery";
 export {
   ApiPaths,
+  CodemationFrontendAuthSnapshotFactory,
+  CodemationFrontendAuthSnapshotJsonCodec,
+  FrontendAppConfigFactory,
+  FrontendAppConfigJsonCodec,
   CodemationConsumerConfigLoader,
   CodemationPostgresPrismaClientFactory,
   CodemationServerGateway,

package/src/infrastructure/persistence/PrismaMigrationDeployer.ts

@@ -7,7 +7,7 @@ import { mkdir } from "node:fs/promises";
 import { createRequire } from "node:module";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import type { ResolvedDatabasePersistence } from "./DatabasePersistenceResolver";
+import type { AppPersistenceConfig } from "../../presentation/config/AppConfig";
 
 /**
  * Runs `prisma migrate deploy` against TCP PostgreSQL or against a PGlite data directory
@@ -17,7 +17,7 @@ import type { ResolvedDatabasePersistence } from "./DatabasePersistenceResolver"
 export class PrismaMigrationDeployer {
   private readonly require = createRequire(import.meta.url);
 
-  async deployPersistence(persistence: ResolvedDatabasePersistence, env?: Readonly<NodeJS.ProcessEnv>): Promise<void> {
+  async deployPersistence(persistence: AppPersistenceConfig, env?: Readonly<NodeJS.ProcessEnv>): Promise<void> {
     if (persistence.kind === "none") {
       return;
     }

package/src/infrastructure/persistence/SchedulerPersistenceCompatibilityValidator.ts

@@ -1,11 +1,11 @@
-import type { ResolvedDatabasePersistence } from "./DatabasePersistenceResolver";
+import type { AppPersistenceConfig } from "../../presentation/config/AppConfig";
 import type { CodemationSchedulerKind } from "../../presentation/config/CodemationConfig";
 
 /**
  * Ensures scheduler and database selections are compatible (e.g. BullMQ requires shared TCP PostgreSQL).
  */
 export class SchedulerPersistenceCompatibilityValidator {
-  validate(args: Readonly<{ schedulerKind: CodemationSchedulerKind; persistence: ResolvedDatabasePersistence }>): void {
+  validate(args: Readonly<{ schedulerKind: CodemationSchedulerKind; persistence: AppPersistenceConfig }>): void {
     if (args.schedulerKind === "bullmq" && args.persistence.kind === "none") {
       throw new Error(
         "BullMQ requires PostgreSQL persistence. Configure runtime.database with a postgresql URL (embedded PGlite is not compatible with BullMQ).",

package/src/infrastructure/scheduler/WorkerRuntimeScheduler.ts

@@ -0,0 +1,16 @@
+import type { NodeExecutionRequestHandler, NodeExecutionScheduler } from "@codemation/core";
+
+export type WorkerRuntimeHandle = Readonly<{
+  stop: () => Promise<void>;
+}>;
+
+export interface WorkerRuntimeScheduler extends NodeExecutionScheduler {
+  createWorker(
+    args: Readonly<{
+      queues: ReadonlyArray<string>;
+      requestHandler: NodeExecutionRequestHandler;
+    }>,
+  ): WorkerRuntimeHandle;
+
+  close(): Promise<void>;
+}

package/src/infrastructure/scheduler/bullmq/BullmqNodeExecutionScheduler.ts

@@ -0,0 +1,47 @@
+import type { NodeExecutionRequest, NodeExecutionScheduler } from "@codemation/core";
+import { Queue } from "bullmq";
+import type { RedisConnectionConfig } from "./RedisConnectionOptionsFactory";
+import { RedisConnectionOptionsFactory } from "./RedisConnectionOptionsFactory";
+
+type QueueName = string;
+
+export class BullmqNodeExecutionScheduler implements NodeExecutionScheduler {
+  private readonly connection: Readonly<Record<string, unknown>>;
+  private readonly queuesByName = new Map<QueueName, Queue>();
+
+  constructor(
+    connection: RedisConnectionConfig,
+    private readonly queuePrefix: string = "codemation",
+  ) {
+    this.connection = RedisConnectionOptionsFactory.fromConfig(connection);
+  }
+
+  async enqueue(request: NodeExecutionRequest): Promise<{ receiptId: string }> {
+    const logical = request.queue ?? "default";
+    const queueName = `${this.queuePrefix}.${logical}`;
+    const queue = this.getOrCreateQueue(queueName);
+    const jobId = `${request.runId}__${request.activationId}`;
+    await queue.add("node-execution", { kind: "nodeExecution", request } as const, {
+      jobId,
+      removeOnComplete: true,
+      removeOnFail: true,
+    });
+    return { receiptId: jobId };
+  }
+
+  async close(): Promise<void> {
+    const queues = [...this.queuesByName.values()];
+    this.queuesByName.clear();
+    await Promise.all(queues.map((queue) => queue.close()));
+  }
+
+  private getOrCreateQueue(name: QueueName): Queue {
+    const existing = this.queuesByName.get(name);
+    if (existing) {
+      return existing;
+    }
+    const queue = new Queue(name, { connection: this.connection as never });
+    this.queuesByName.set(name, queue);
+    return queue;
+  }
+}

package/src/infrastructure/scheduler/bullmq/BullmqScheduler.ts

@@ -0,0 +1,33 @@
+import type { NodeExecutionRequest, NodeExecutionRequestHandler } from "@codemation/core";
+import type { WorkerRuntimeScheduler } from "../WorkerRuntimeScheduler";
+import type { RedisConnectionConfig } from "./RedisConnectionOptionsFactory";
+import { BullmqNodeExecutionScheduler } from "./BullmqNodeExecutionScheduler";
+import { BullmqWorker } from "./BullmqWorker";
+
+export class BullmqScheduler implements WorkerRuntimeScheduler {
+  private readonly scheduler: BullmqNodeExecutionScheduler;
+
+  constructor(
+    private readonly connection: RedisConnectionConfig,
+    private readonly queuePrefix: string = "codemation",
+  ) {
+    this.scheduler = new BullmqNodeExecutionScheduler(connection, queuePrefix);
+  }
+
+  async enqueue(request: NodeExecutionRequest): Promise<{ receiptId: string }> {
+    return await this.scheduler.enqueue(request);
+  }
+
+  async close(): Promise<void> {
+    await this.scheduler.close();
+  }
+
+  createWorker(
+    args: Readonly<{
+      queues: ReadonlyArray<string>;
+      requestHandler: NodeExecutionRequestHandler;
+    }>,
+  ): BullmqWorker {
+    return new BullmqWorker(this.connection, args.queues, this.queuePrefix, args.requestHandler);
+  }
+}

package/src/infrastructure/scheduler/bullmq/BullmqWorker.ts

@@ -0,0 +1,48 @@
+import type { NodeExecutionRequest, NodeExecutionRequestHandler } from "@codemation/core";
+import type { Job } from "bullmq";
+import { Worker } from "bullmq";
+import type { RedisConnectionConfig } from "./RedisConnectionOptionsFactory";
+import { RedisConnectionOptionsFactory } from "./RedisConnectionOptionsFactory";
+
+type NodeExecutionJobData = Readonly<{
+  kind: "nodeExecution";
+  request: NodeExecutionRequest;
+}>;
+
+export class BullmqWorker {
+  private readonly connection: Readonly<Record<string, unknown>>;
+  private readonly workers: Worker[] = [];
+
+  constructor(
+    connection: RedisConnectionConfig,
+    queues: ReadonlyArray<string>,
+    queuePrefix: string,
+    private readonly requestHandler: NodeExecutionRequestHandler,
+  ) {
+    this.connection = RedisConnectionOptionsFactory.fromConfig(connection);
+    for (const queue of queues) {
+      const queueName = `${queuePrefix}.${queue}`;
+      this.workers.push(
+        new Worker(queueName, async (job: Job) => await this.processJob(queueName, job), {
+          connection: this.connection as never,
+        }),
+      );
+    }
+  }
+
+  async waitUntilReady(): Promise<void> {
+    await Promise.all(this.workers.map((worker) => worker.waitUntilReady()));
+  }
+
+  async stop(): Promise<void> {
+    await Promise.all(this.workers.map((worker) => worker.close()));
+  }
+
+  private async processJob(queueName: string, job: Job): Promise<void> {
+    const data = job.data as NodeExecutionJobData;
+    if (!data || data.kind !== "nodeExecution") {
+      throw new Error(`Unexpected job payload for queue ${queueName}`);
+    }
+    await this.requestHandler.handleNodeExecutionRequest(data.request);
+  }
+}

package/src/infrastructure/scheduler/bullmq/RedisConnectionOptionsFactory.ts

@@ -0,0 +1,48 @@
+export type RedisConnectionConfig =
+  | Readonly<{ url: string }>
+  | Readonly<{
+      host: string;
+      port: number;
+      username?: string;
+      password?: string;
+      db?: number;
+      tls?: boolean;
+    }>;
+
+export class RedisConnectionOptionsFactory {
+  private static readonly bullMqIoredisDefaults = {
+    maxRetriesPerRequest: null,
+  } as const;
+
+  static fromConfig(cfg: RedisConnectionConfig): Readonly<Record<string, unknown>> {
+    if ("url" in cfg) {
+      return this.fromUrl(cfg.url);
+    }
+    const { host, port, username, password, db, tls } = cfg;
+    return {
+      ...this.bullMqIoredisDefaults,
+      host,
+      port,
+      ...(username ? { username } : {}),
+      ...(password ? { password } : {}),
+      ...(typeof db === "number" ? { db } : {}),
+      ...(tls ? { tls: {} } : {}),
+    };
+  }
+
+  static fromUrl(redisUrl: string): Readonly<Record<string, unknown>> {
+    const url = new URL(redisUrl);
+    if (url.protocol !== "redis:" && url.protocol !== "rediss:") {
+      throw new Error(`Unsupported redis URL protocol: ${url.protocol}`);
+    }
+    const db = url.pathname && url.pathname !== "/" ? Number(url.pathname.slice(1)) : undefined;
+    return this.fromConfig({
+      host: url.hostname,
+      port: url.port ? Number(url.port) : 6379,
+      username: url.username || undefined,
+      password: url.password || undefined,
+      db: typeof db === "number" && !Number.isNaN(db) ? db : undefined,
+      tls: url.protocol === "rediss:",
+    });
+  }
+}

package/src/nextServer.ts

@@ -14,11 +14,20 @@ export { WorkflowDefinitionMapper } from "./application/mapping/WorkflowDefiniti
 export { WorkflowPolicyUiPresentationFactory } from "./application/mapping/WorkflowPolicyUiPresentationFactory";
 export { WorkflowRunRetentionPruneScheduler } from "./application/runs/WorkflowRunRetentionPruneScheduler";
 export { ApplicationTokens } from "./applicationTokens";
-export { CodemationApplication } from "./codemationApplication";
+export { AppContainerFactory } from "./bootstrap/AppContainerFactory";
+export { AppContainerLifecycle } from "./bootstrap/AppContainerLifecycle";
+export { DatabaseMigrations } from "./bootstrap/runtime/DatabaseMigrations";
+export { FrontendRuntime } from "./bootstrap/runtime/FrontendRuntime";
+export { WorkerRuntime } from "./bootstrap/runtime/WorkerRuntime";
+export { AppConfigFactory } from "./bootstrap/runtime/AppConfigFactory";
 export { CodemationBootstrapRequest } from "./bootstrap/CodemationBootstrapRequest";
-export { CodemationFrontendBootstrapRequest } from "./bootstrap/CodemationFrontendBootstrapRequest";
-export { CodemationWorkerBootstrapRequest } from "./bootstrap/CodemationWorkerBootstrapRequest";
 export { CodemationPluginListMerger } from "./presentation/config/CodemationPluginListMerger";
+export type {
+  CodemationFrontendAuthProviderSnapshot,
+  CodemationFrontendAuthSnapshot,
+} from "./presentation/frontend/CodemationFrontendAuthSnapshot";
+export type { FrontendAppConfig } from "./presentation/frontend/FrontendAppConfig";
+export { FrontendAppConfigFactory } from "./presentation/frontend/FrontendAppConfigFactory";
 export { CredentialBindingService, CredentialInstanceService } from "./domain/credentials/CredentialServices";
 export { RequestToWebhookItemMapper } from "./infrastructure/webhooks/RequestToWebhookItemMapper";
 export { CodemationHonoApiApp } from "./presentation/http/hono/CodemationHonoApiAppFactory";

package/src/persistenceServer.ts

@@ -1,5 +1,5 @@
 export { CodemationPostgresPrismaClientFactory } from "./infrastructure/persistence/CodemationPostgresPrismaClientFactory";
-export { DatabasePersistenceResolver } from "./infrastructure/persistence/DatabasePersistenceResolver";
-export type { ResolvedDatabasePersistence } from "./infrastructure/persistence/DatabasePersistenceResolver";
+export type { AppPersistenceConfig } from "./presentation/config/AppConfig";
+export { AppConfigFactory } from "./bootstrap/runtime/AppConfigFactory";
 export { PrismaMigrationDeployer } from "./infrastructure/persistence/PrismaMigrationDeployer";
 export { PrismaClient } from "./infrastructure/persistence/generated/prisma-client/client.js";