@codemation/host 0.0.5 → 0.0.11

package/src/bootstrap/PreparedCodemationRuntimeFactory.ts

@@ -1,308 +0,0 @@
-import type { PGlite } from "@electric-sql/pglite";
-import path from "node:path";
-import type {
-  Container,
-  RunEventBus,
-  TriggerSetupStateRepository,
-  WorkflowExecutionRepository,
-} from "@codemation/core";
-import {
-  CoreTokens,
-  EventPublishingWorkflowExecutionRepository,
-  InMemoryRunEventBus,
-  instanceCachingFactory,
-  SystemClock,
-} from "@codemation/core";
-import {
-  ConfigDrivenOffloadPolicy,
-  DefaultDrivingScheduler,
-  DefaultExecutionContextFactory,
-  InlineDrivingScheduler,
-  InMemoryBinaryStorage,
-  InMemoryRunDataFactory,
-} from "@codemation/core/bootstrap";
-import { RedisRunEventBus } from "@codemation/eventbus-redis";
-import type { BootRuntimeSummary } from "../application/dev/BootRuntimeSummary.types";
-import { BootRuntimeSnapshotHolder } from "../application/dev/BootRuntimeSnapshotHolder";
-import { ApplicationTokens } from "../applicationTokens";
-import { UserAccountService } from "../domain/users/UserAccountServiceRegistry";
-import type { WorkflowRunRepository } from "../domain/runs/WorkflowRunRepository";
-import type { WorkflowDebuggerOverlayRepository } from "../domain/workflows/WorkflowDebuggerOverlayRepository";
-import type { CodemationAuthConfig } from "../presentation/config/CodemationAuthConfig";
-import type { CodemationApplicationRuntimeConfig } from "../presentation/config/CodemationConfig";
-import type { CodemationWhitelabelConfig } from "../presentation/config/CodemationWhitelabelConfig";
-import { CredentialSessionServiceImpl } from "../domain/credentials/CredentialServices";
-import { LocalFilesystemBinaryStorage } from "../infrastructure/binary/LocalFilesystemBinaryStorageRegistry";
-import {
-  InMemoryCredentialStore,
-  PrismaCredentialStore,
-} from "../infrastructure/persistence/CredentialPersistenceStore";
-import { InMemoryTriggerSetupStateRepository } from "../infrastructure/persistence/InMemoryTriggerSetupStateRepository";
-import { InMemoryWorkflowActivationRepository } from "../infrastructure/persistence/InMemoryWorkflowActivationRepository";
-import { InMemoryWorkflowDebuggerOverlayRepository } from "../infrastructure/persistence/InMemoryWorkflowDebuggerOverlayRepository";
-import { InMemoryWorkflowRunRepository } from "../infrastructure/persistence/InMemoryWorkflowRunRepository";
-import { PrismaClientFactory } from "../infrastructure/persistence/PrismaClientFactory";
-import { PrismaClient } from "../infrastructure/persistence/generated/prisma-client/client.js";
-import { PrismaTriggerSetupStateRepository } from "../infrastructure/persistence/PrismaTriggerSetupStateRepository";
-import { PrismaWorkflowActivationRepository } from "../infrastructure/persistence/PrismaWorkflowActivationRepository";
-import { PrismaWorkflowDebuggerOverlayRepository } from "../infrastructure/persistence/PrismaWorkflowDebuggerOverlayRepository";
-import { PrismaWorkflowRunRepository } from "../infrastructure/persistence/PrismaWorkflowRunRepository";
-import type { ResolvedDatabasePersistence } from "../infrastructure/persistence/DatabasePersistenceResolver";
-import { AppConfigFactory } from "./runtime/AppConfigFactory";
-import type { ResolvedImplementationSelection } from "./runtime/ResolvedImplementationSelectionFactory";
-import { ResolvedImplementationSelectionFactory } from "./runtime/ResolvedImplementationSelectionFactory";
-import { PreparedCodemationRuntime } from "./PreparedCodemationRuntime";
-import type { AppConfig } from "../presentation/config/AppConfig";
-
-type PrismaClientResolution = Readonly<{
-  prismaClient: PrismaClient;
-  ownedPrismaClient?: PrismaClient;
-  ownedPglite?: PGlite;
-}>;
-
-type PreparedRuntimePersistence = Readonly<{
-  workflowExecutionRepository: WorkflowExecutionRepository;
-  triggerSetupStateRepository: TriggerSetupStateRepository;
-  workflowRunRepository?: WorkflowRunRepository;
-  workflowDebuggerOverlayRepository: WorkflowDebuggerOverlayRepository;
-  prismaClient?: PrismaClient;
-  ownedPrismaClient?: PrismaClient;
-  ownedPglite?: PGlite;
-}>;
-
-export class PreparedCodemationRuntimeFactory {
-  constructor(
-    private readonly implementationSelectionFactory: ResolvedImplementationSelectionFactory = new ResolvedImplementationSelectionFactory(),
-    private readonly appConfigFactory: AppConfigFactory = new AppConfigFactory(),
-  ) {}
-
-  async prepare(
-    args: Readonly<{
-      container: Container;
-      repoRoot: string;
-      consumerRoot: string;
-      env: NodeJS.ProcessEnv;
-      workflowSources: ReadonlyArray<string>;
-      runtimeConfig: CodemationApplicationRuntimeConfig;
-      applicationAuthConfig: CodemationAuthConfig | undefined;
-      whitelabelConfig: CodemationWhitelabelConfig;
-      hasConfiguredCredentialSessionServiceRegistration: boolean;
-    }>,
-  ): Promise<PreparedCodemationRuntime> {
-    const usesProvidedPrismaClientOverride = this.hasProvidedPrismaClientOverride(args.container);
-    const implementationSelection = this.implementationSelectionFactory.resolve({
-      consumerRoot: args.consumerRoot,
-      env: args.env,
-      runtimeConfig: args.runtimeConfig,
-    });
-    const runtimeSummary = this.createRuntimeSummary(implementationSelection);
-    args.container.resolve(BootRuntimeSnapshotHolder).set(runtimeSummary);
-    const eventBus = this.createRunEventBus(implementationSelection);
-    const persistence = await this.createRunPersistence(args.container, implementationSelection, eventBus);
-    const binaryStorage = this.createBinaryStorage(args.repoRoot);
-    const appConfig: AppConfig = this.appConfigFactory.create({
-      repoRoot: args.repoRoot,
-      consumerRoot: args.consumerRoot,
-      env: args.env,
-      workflowSources: args.workflowSources,
-      runtimeConfig: args.runtimeConfig,
-      authConfig: args.applicationAuthConfig,
-      whitelabelConfig: args.whitelabelConfig,
-    });
-
-    args.container.registerInstance(CoreTokens.RunEventBus, eventBus);
-    args.container.registerInstance(CoreTokens.WorkflowExecutionRepository, persistence.workflowExecutionRepository);
-    args.container.registerInstance(CoreTokens.TriggerSetupStateRepository, persistence.triggerSetupStateRepository);
-    args.container.registerInstance(CoreTokens.RunDataFactory, new InMemoryRunDataFactory());
-    args.container.registerInstance(CoreTokens.BinaryStorage, binaryStorage);
-    args.container.registerInstance(
-      CoreTokens.ExecutionContextFactory,
-      new DefaultExecutionContextFactory(binaryStorage),
-    );
-    args.container.registerInstance(ApplicationTokens.AppConfig, appConfig);
-    args.container.registerInstance(ApplicationTokens.Clock, new SystemClock());
-    args.container.registerInstance(ApplicationTokens.CodemationAuthConfig, args.applicationAuthConfig);
-    args.container.registerInstance(ApplicationTokens.CodemationWhitelabelConfig, args.whitelabelConfig);
-    args.container.registerInstance(ApplicationTokens.WebSocketPort, this.resolveWebSocketPort(args.env));
-    args.container.registerInstance(ApplicationTokens.WebSocketBindHost, args.env.CODEMATION_WS_BIND_HOST ?? "0.0.0.0");
-    args.container.register(UserAccountService, {
-      useFactory: instanceCachingFactory((dependencyContainer) => {
-        const prismaClient = dependencyContainer.isRegistered(PrismaClient, true)
-          ? dependencyContainer.resolve(PrismaClient)
-          : undefined;
-        return new UserAccountService(
-          dependencyContainer.resolve(ApplicationTokens.CodemationAuthConfig),
-          prismaClient,
-        );
-      }),
-    });
-    args.container.registerInstance(
-      ApplicationTokens.WorkflowDebuggerOverlayRepository,
-      persistence.workflowDebuggerOverlayRepository,
-    );
-    if (persistence.workflowRunRepository) {
-      args.container.registerInstance(ApplicationTokens.WorkflowRunRepository, persistence.workflowRunRepository);
-    }
-    if (persistence.prismaClient) {
-      args.container.registerInstance(PrismaClient, persistence.prismaClient);
-      args.container.registerInstance(ApplicationTokens.PrismaClient, persistence.prismaClient);
-    }
-    const workflowActivationRepository = persistence.prismaClient
-      ? args.container.resolve(PrismaWorkflowActivationRepository)
-      : args.container.resolve(InMemoryWorkflowActivationRepository);
-    args.container.registerInstance(ApplicationTokens.WorkflowActivationRepository, workflowActivationRepository);
-    if (implementationSelection.databasePersistence.kind !== "none") {
-      args.container.registerInstance(ApplicationTokens.CredentialStore, args.container.resolve(PrismaCredentialStore));
-    } else {
-      args.container.registerInstance(
-        ApplicationTokens.CredentialStore,
-        args.container.resolve(InMemoryCredentialStore),
-      );
-    }
-    if (!args.hasConfiguredCredentialSessionServiceRegistration) {
-      args.container.register(CoreTokens.CredentialSessionService, {
-        useFactory: instanceCachingFactory((dependencyContainer) =>
-          dependencyContainer.resolve(CredentialSessionServiceImpl),
-        ),
-      });
-    }
-    if (implementationSelection.workerRuntimeScheduler) {
-      args.container.registerInstance(
-        ApplicationTokens.WorkerRuntimeScheduler,
-        implementationSelection.workerRuntimeScheduler,
-      );
-    }
-    this.registerRuntimeNodeActivationScheduler(args.container);
-
-    return new PreparedCodemationRuntime(
-      args.container,
-      runtimeSummary,
-      implementationSelection,
-      usesProvidedPrismaClientOverride,
-      persistence.ownedPrismaClient ?? null,
-      persistence.ownedPglite ?? null,
-    );
-  }
-
-  private createRuntimeSummary(selection: ResolvedImplementationSelection): BootRuntimeSummary {
-    return {
-      databasePersistence: selection.databasePersistence,
-      eventBusKind: selection.eventBusKind,
-      queuePrefix: selection.queuePrefix,
-      schedulerKind: selection.schedulerKind,
-      redisUrl: selection.redisUrl,
-    };
-  }
-
-  private createRunEventBus(selection: ResolvedImplementationSelection): RunEventBus {
-    if (selection.eventBusKind === "redis") {
-      return new RedisRunEventBus(this.requireRedisUrl(selection.redisUrl), selection.queuePrefix);
-    }
-    return new InMemoryRunEventBus();
-  }
-
-  private async createRunPersistence(
-    container: Container,
-    selection: ResolvedImplementationSelection,
-    eventBus: RunEventBus,
-  ): Promise<PreparedRuntimePersistence> {
-    if (selection.databasePersistence.kind === "none") {
-      const workflowRunRepository = container.resolve(InMemoryWorkflowRunRepository);
-      return {
-        workflowRunRepository,
-        triggerSetupStateRepository: container.resolve(InMemoryTriggerSetupStateRepository),
-        workflowDebuggerOverlayRepository: container.resolve(InMemoryWorkflowDebuggerOverlayRepository),
-        workflowExecutionRepository: new EventPublishingWorkflowExecutionRepository(workflowRunRepository, eventBus),
-      };
-    }
-    const prismaClientResolution = await this.resolveInjectedOrOwnedPrismaClient(
-      container,
-      selection.databasePersistence,
-    );
-    const childContainer = container.createChildContainer();
-    childContainer.registerInstance(PrismaClient, prismaClientResolution.prismaClient);
-    const workflowRunRepository = childContainer.resolve(PrismaWorkflowRunRepository);
-    const triggerSetupStateRepository = childContainer.resolve(PrismaTriggerSetupStateRepository);
-    const workflowDebuggerOverlayRepository = childContainer.resolve(PrismaWorkflowDebuggerOverlayRepository);
-    return {
-      prismaClient: prismaClientResolution.prismaClient,
-      ownedPrismaClient: prismaClientResolution.ownedPrismaClient,
-      ownedPglite: prismaClientResolution.ownedPglite,
-      workflowRunRepository,
-      triggerSetupStateRepository,
-      workflowDebuggerOverlayRepository,
-      workflowExecutionRepository: new EventPublishingWorkflowExecutionRepository(workflowRunRepository, eventBus),
-    };
-  }
-
-  private hasProvidedPrismaClientOverride(container: Container): boolean {
-    return container.isRegistered(PrismaClient, true);
-  }
-
-  private async resolveInjectedOrOwnedPrismaClient(
-    container: Container,
-    persistence: Exclude<ResolvedDatabasePersistence, Readonly<{ kind: "none" }>>,
-  ): Promise<PrismaClientResolution> {
-    if (this.hasProvidedPrismaClientOverride(container)) {
-      return {
-        prismaClient: container.resolve(PrismaClient),
-      };
-    }
-    const factory = container.resolve(PrismaClientFactory);
-    if (persistence.kind === "postgresql") {
-      const prismaClient = factory.createPostgres(persistence.databaseUrl);
-      return {
-        prismaClient,
-        ownedPrismaClient: prismaClient,
-      };
-    }
-    if (persistence.kind !== "pglite") {
-      throw new Error("Unexpected database persistence mode for Prisma.");
-    }
-    const { prismaClient, pglite } = await factory.createPglite(persistence.dataDir);
-    return {
-      prismaClient,
-      ownedPrismaClient: prismaClient,
-      ownedPglite: pglite,
-    };
-  }
-
-  private registerRuntimeNodeActivationScheduler(container: Container): void {
-    container.register(CoreTokens.NodeActivationScheduler, {
-      useFactory: instanceCachingFactory((dependencyContainer) => {
-        const inlineScheduler = dependencyContainer.resolve(InlineDrivingScheduler);
-        if (!dependencyContainer.isRegistered(ApplicationTokens.WorkerRuntimeScheduler, true)) {
-          return inlineScheduler;
-        }
-        return new DefaultDrivingScheduler(
-          new ConfigDrivenOffloadPolicy(),
-          dependencyContainer.resolve(ApplicationTokens.WorkerRuntimeScheduler),
-          inlineScheduler,
-        );
-      }),
-    });
-  }
-
-  private createBinaryStorage(repoRoot: string): InMemoryBinaryStorage | LocalFilesystemBinaryStorage {
-    if (!repoRoot) {
-      return new InMemoryBinaryStorage();
-    }
-    return new LocalFilesystemBinaryStorage(path.join(repoRoot, ".codemation", "binary"));
-  }
-
-  private requireRedisUrl(redisUrl: string | undefined): string {
-    if (!redisUrl) {
-      throw new Error("Redis-backed runtime requires runtime.eventBus.redisUrl or REDIS_URL.");
-    }
-    return redisUrl;
-  }
-
-  private resolveWebSocketPort(env: Readonly<NodeJS.ProcessEnv>): number {
-    const rawPort = env.CODEMATION_WS_PORT ?? env.VITE_CODEMATION_WS_PORT;
-    const parsedPort = Number(rawPort);
-    if (Number.isInteger(parsedPort) && parsedPort > 0) {
-      return parsedPort;
-    }
-    return 3001;
-  }
-}

package/src/bootstrap/boot/CliRuntimeBootService.ts

@@ -1,27 +0,0 @@
-import { PrismaMigrationDeployer } from "../../infrastructure/persistence/PrismaMigrationDeployer";
-import { RuntimeWorkflowActivationPolicy } from "../../infrastructure/persistence/RuntimeWorkflowActivationPolicy";
-import { ApplicationTokens } from "../../applicationTokens";
-import { PreparedCodemationRuntime } from "../PreparedCodemationRuntime";
-
-export class CliRuntimeBootService {
-  async boot(args: Readonly<{ preparedRuntime: PreparedCodemationRuntime }>): Promise<void> {
-    await this.applyDatabaseMigrations(args.preparedRuntime);
-    await args.preparedRuntime.container
-      .resolve(RuntimeWorkflowActivationPolicy)
-      .hydrateFromRepository(args.preparedRuntime.container.resolve(ApplicationTokens.WorkflowActivationRepository));
-  }
-
-  private async applyDatabaseMigrations(preparedRuntime: PreparedCodemationRuntime): Promise<void> {
-    const appConfig = preparedRuntime.container.resolve(ApplicationTokens.AppConfig);
-    if (
-      preparedRuntime.implementationSelection.databasePersistence.kind === "none" ||
-      preparedRuntime.usesProvidedPrismaClientOverride ||
-      appConfig.env.CODEMATION_SKIP_STARTUP_MIGRATIONS === "true"
-    ) {
-      return;
-    }
-    await preparedRuntime.container
-      .resolve(PrismaMigrationDeployer)
-      .deployPersistence(preparedRuntime.implementationSelection.databasePersistence, appConfig.env);
-  }
-}

package/src/bootstrap/boot/FrontendRuntimeBootService.ts

@@ -1,86 +0,0 @@
-import { CoreTokens } from "@codemation/core";
-import { instanceCachingFactory } from "@codemation/core";
-import { Engine } from "@codemation/core/bootstrap";
-import { PrismaMigrationDeployer } from "../../infrastructure/persistence/PrismaMigrationDeployer";
-import { RuntimeWorkflowActivationPolicy } from "../../infrastructure/persistence/RuntimeWorkflowActivationPolicy";
-import { DevelopmentSessionBypassVerifier } from "../../infrastructure/auth/DevelopmentSessionBypassVerifier";
-import { AuthJsSessionVerifier } from "../../infrastructure/auth/AuthJsSessionVerifier";
-import { ApplicationTokens } from "../../applicationTokens";
-import { WorkflowRunEventWebsocketRelay } from "../../application/websocket/WorkflowRunEventWebsocketRelay";
-import { ApiPaths } from "../../presentation/http/ApiPaths";
-import { WorkflowWebsocketServer } from "../../presentation/websocket/WorkflowWebsocketServer";
-import { PreparedCodemationRuntime } from "../PreparedCodemationRuntime";
-
-export class FrontendRuntimeBootService {
-  async boot(
-    args: Readonly<{
-      preparedRuntime: PreparedCodemationRuntime;
-      skipPresentationServers?: boolean;
-    }>,
-  ): Promise<void> {
-    await this.applyDatabaseMigrations(args.preparedRuntime);
-    await this.hydrateWorkflowActivationPolicy(args.preparedRuntime);
-    this.registerSessionVerification(args.preparedRuntime);
-    args.preparedRuntime.container.registerInstance(CoreTokens.WebhookBasePath, ApiPaths.webhooks());
-    if (args.skipPresentationServers === true) {
-      return;
-    }
-    const workflowRepository = args.preparedRuntime.container.resolve(CoreTokens.WorkflowRepository);
-    await args.preparedRuntime.container.resolve(Engine).start([...workflowRepository.list()]);
-    await args.preparedRuntime.container.resolve(WorkflowWebsocketServer).start();
-    await args.preparedRuntime.container.resolve(WorkflowRunEventWebsocketRelay).start();
-  }
-
-  private async applyDatabaseMigrations(preparedRuntime: PreparedCodemationRuntime): Promise<void> {
-    const appConfig = preparedRuntime.container.resolve(ApplicationTokens.AppConfig);
-    if (
-      preparedRuntime.implementationSelection.databasePersistence.kind === "none" ||
-      preparedRuntime.usesProvidedPrismaClientOverride ||
-      appConfig.env.CODEMATION_SKIP_STARTUP_MIGRATIONS === "true"
-    ) {
-      return;
-    }
-    await preparedRuntime.container
-      .resolve(PrismaMigrationDeployer)
-      .deployPersistence(preparedRuntime.implementationSelection.databasePersistence, appConfig.env);
-  }
-
-  private async hydrateWorkflowActivationPolicy(preparedRuntime: PreparedCodemationRuntime): Promise<void> {
-    await preparedRuntime.container
-      .resolve(RuntimeWorkflowActivationPolicy)
-      .hydrateFromRepository(preparedRuntime.container.resolve(ApplicationTokens.WorkflowActivationRepository));
-  }
-
-  private registerSessionVerification(preparedRuntime: PreparedCodemationRuntime): void {
-    const appConfig = preparedRuntime.container.resolve(ApplicationTokens.AppConfig);
-    const env = appConfig.env;
-    const authConfig = appConfig.auth;
-    const isProduction = env.NODE_ENV === "production";
-    if (isProduction && !authConfig) {
-      throw new Error("CodemationConfig.auth is required when NODE_ENV is production.");
-    }
-    if (isProduction && authConfig?.allowUnauthenticatedInDevelopment === true) {
-      throw new Error(
-        "CodemationAuthConfig.allowUnauthenticatedInDevelopment is not allowed when NODE_ENV is production.",
-      );
-    }
-    const bypassAllowed = !isProduction && authConfig?.allowUnauthenticatedInDevelopment === true;
-    if (bypassAllowed) {
-      preparedRuntime.container.register(ApplicationTokens.SessionVerifier, {
-        useFactory: instanceCachingFactory((dependencyContainer) =>
-          dependencyContainer.resolve(DevelopmentSessionBypassVerifier),
-        ),
-      });
-      return;
-    }
-    const secret = env.AUTH_SECRET ?? "";
-    if (!secret) {
-      throw new Error(
-        "AUTH_SECRET is required unless CodemationAuthConfig.allowUnauthenticatedInDevelopment is enabled in a non-production environment.",
-      );
-    }
-    preparedRuntime.container.register(ApplicationTokens.SessionVerifier, {
-      useFactory: instanceCachingFactory((dependencyContainer) => dependencyContainer.resolve(AuthJsSessionVerifier)),
-    });
-  }
-}

package/src/bootstrap/boot/WorkerRuntimeBootService.ts

@@ -1,64 +0,0 @@
-import { CoreTokens } from "@codemation/core";
-import { Engine } from "@codemation/core/bootstrap";
-import type { WorkerRuntimeHandle } from "../../infrastructure/runtime/WorkerRuntimeScheduler";
-import { PrismaMigrationDeployer } from "../../infrastructure/persistence/PrismaMigrationDeployer";
-import { RuntimeWorkflowActivationPolicy } from "../../infrastructure/persistence/RuntimeWorkflowActivationPolicy";
-import { ApplicationTokens } from "../../applicationTokens";
-import { ApiPaths } from "../../presentation/http/ApiPaths";
-import { PreparedCodemationRuntime } from "../PreparedCodemationRuntime";
-
-export class WorkerRuntimeBootService {
-  async boot(
-    args: Readonly<{
-      preparedRuntime: PreparedCodemationRuntime;
-      queues: ReadonlyArray<string>;
-    }>,
-  ): Promise<Readonly<{ stop: () => Promise<void> }>> {
-    await this.applyDatabaseMigrations(args.preparedRuntime);
-    await args.preparedRuntime.container
-      .resolve(RuntimeWorkflowActivationPolicy)
-      .hydrateFromRepository(args.preparedRuntime.container.resolve(ApplicationTokens.WorkflowActivationRepository));
-    args.preparedRuntime.container.registerInstance(CoreTokens.WebhookBasePath, ApiPaths.webhooks());
-    if (!args.preparedRuntime.container.isRegistered(ApplicationTokens.WorkerRuntimeScheduler, true)) {
-      throw new Error("Worker mode requires a BullMQ scheduler backed by a Redis event bus.");
-    }
-    const workflows = args.preparedRuntime.container.resolve(CoreTokens.WorkflowRepository).list();
-    const engine = args.preparedRuntime.container.resolve(Engine);
-    await engine.start([...workflows]);
-    const workflowsById = new Map(workflows.map((workflow) => [workflow.id, workflow] as const));
-    const scheduler = args.preparedRuntime.container.resolve(ApplicationTokens.WorkerRuntimeScheduler);
-    const executionLimitsPolicy = args.preparedRuntime.container.resolve(CoreTokens.EngineExecutionLimitsPolicy);
-    const worker: WorkerRuntimeHandle = scheduler.createWorker({
-      queues: args.queues,
-      workflowsById,
-      nodeResolver: args.preparedRuntime.container.resolve(CoreTokens.NodeResolver),
-      credentialSessions: args.preparedRuntime.container.resolve(CoreTokens.CredentialSessionService),
-      workflowExecutionRepository: args.preparedRuntime.container.resolve(CoreTokens.WorkflowExecutionRepository),
-      continuation: engine,
-      binaryStorage: args.preparedRuntime.container.resolve(CoreTokens.BinaryStorage),
-      workflows: args.preparedRuntime.container.resolve(CoreTokens.WorkflowRunnerService),
-      executionLimitsPolicy,
-    });
-    return {
-      stop: async () => {
-        await worker.stop();
-        await scheduler.close();
-        await args.preparedRuntime.stop({ stopWebsocketServer: false });
-      },
-    };
-  }
-
-  private async applyDatabaseMigrations(preparedRuntime: PreparedCodemationRuntime): Promise<void> {
-    const appConfig = preparedRuntime.container.resolve(ApplicationTokens.AppConfig);
-    if (
-      preparedRuntime.implementationSelection.databasePersistence.kind === "none" ||
-      preparedRuntime.usesProvidedPrismaClientOverride ||
-      appConfig.env.CODEMATION_SKIP_STARTUP_MIGRATIONS === "true"
-    ) {
-      return;
-    }
-    await preparedRuntime.container
-      .resolve(PrismaMigrationDeployer)
-      .deployPersistence(preparedRuntime.implementationSelection.databasePersistence, appConfig.env);
-  }
-}

package/src/bootstrap/runtime/ResolvedImplementationSelectionFactory.ts

@@ -1,118 +0,0 @@
-import { BullmqScheduler } from "@codemation/queue-bullmq";
-import type { WorkerRuntimeScheduler } from "../../infrastructure/runtime/WorkerRuntimeScheduler";
-import type { ResolvedDatabasePersistence } from "../../infrastructure/persistence/DatabasePersistenceResolver";
-import { DatabasePersistenceResolver } from "../../infrastructure/persistence/DatabasePersistenceResolver";
-import { SchedulerPersistenceCompatibilityValidator } from "../../infrastructure/persistence/SchedulerPersistenceCompatibilityValidator";
-import type {
-  CodemationApplicationRuntimeConfig,
-  CodemationEventBusKind,
-  CodemationSchedulerKind,
-} from "../../presentation/config/CodemationConfig";
-
-export type ResolvedImplementationSelection = Readonly<{
-  databasePersistence: ResolvedDatabasePersistence;
-  eventBusKind: CodemationEventBusKind;
-  queuePrefix: string;
-  redisUrl?: string;
-  schedulerKind: CodemationSchedulerKind;
-  workerRuntimeScheduler?: WorkerRuntimeScheduler;
-}>;
-
-export class ResolvedImplementationSelectionFactory {
-  constructor(
-    private readonly databasePersistenceResolver: DatabasePersistenceResolver = new DatabasePersistenceResolver(),
-    private readonly schedulerPersistenceCompatibilityValidator: SchedulerPersistenceCompatibilityValidator = new SchedulerPersistenceCompatibilityValidator(),
-  ) {}
-
-  resolve(
-    args: Readonly<{
-      consumerRoot: string;
-      runtimeConfig: CodemationApplicationRuntimeConfig;
-      env: Readonly<NodeJS.ProcessEnv>;
-    }>,
-  ): ResolvedImplementationSelection {
-    const databasePersistence = this.databasePersistenceResolver.resolve({
-      runtimeConfig: args.runtimeConfig,
-      env: args.env,
-      consumerRoot: args.consumerRoot,
-    });
-    const redisUrl = args.runtimeConfig.eventBus?.redisUrl ?? args.env.REDIS_URL;
-    const schedulerKind = this.resolveSchedulerKind(args.runtimeConfig, args.env, redisUrl);
-    const eventBusKind = this.resolveEventBusKind(args.runtimeConfig, args.env, schedulerKind, redisUrl);
-    const queuePrefix =
-      args.runtimeConfig.scheduler?.queuePrefix ??
-      args.runtimeConfig.eventBus?.queuePrefix ??
-      args.env.QUEUE_PREFIX ??
-      "codemation";
-    if (schedulerKind === "bullmq" && eventBusKind !== "redis") {
-      throw new Error(
-        "BullMQ scheduling requires a Redis event bus so worker events can be forwarded to connected clients.",
-      );
-    }
-    if (eventBusKind === "redis" && !redisUrl) {
-      throw new Error("Redis event bus requires runtime.eventBus.redisUrl or REDIS_URL.");
-    }
-    this.schedulerPersistenceCompatibilityValidator.validate({ schedulerKind, persistence: databasePersistence });
-    const workerRuntimeScheduler =
-      schedulerKind === "bullmq"
-        ? new BullmqScheduler({ url: this.requireRedisUrl(redisUrl) }, queuePrefix)
-        : undefined;
-    return {
-      databasePersistence,
-      eventBusKind,
-      queuePrefix,
-      redisUrl,
-      schedulerKind,
-      workerRuntimeScheduler,
-    };
-  }
-
-  private resolveSchedulerKind(
-    runtimeConfig: CodemationApplicationRuntimeConfig,
-    env: Readonly<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: Readonly<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 requireRedisUrl(redisUrl: string | undefined): string {
-    if (!redisUrl) {
-      throw new Error("Redis-backed runtime requires runtime.eventBus.redisUrl or REDIS_URL.");
-    }
-    return redisUrl;
-  }
-}