@codemation/host 0.0.1

package/src/bootstrap/CodemationContainerRegistrationRegistrar.ts

@@ -0,0 +1,42 @@
+import type { Container } from "@codemation/core";
+import type {
+  CodemationClassRegistration,
+  CodemationContainerRegistration,
+  CodemationValueRegistration,
+} from "./CodemationContainerRegistration";
+
+export class CodemationContainerRegistrationRegistrar {
+  apply(container: Container, registrations: ReadonlyArray<CodemationContainerRegistration<unknown>>): void {
+    for (const registration of registrations) {
+      this.applyRegistration(container, registration);
+    }
+  }
+
+  private applyRegistration(container: Container, registration: CodemationContainerRegistration<unknown>): void {
+    if (this.isValueRegistration(registration)) {
+      container.registerInstance(registration.token, registration.useValue);
+      return;
+    }
+    if (this.isClassRegistration(registration)) {
+      container.register(registration.token, {
+        useClass: registration.useClass as never,
+      });
+      return;
+    }
+    container.register(registration.token, {
+      useFactory: (dependencyContainer) => registration.useFactory(dependencyContainer),
+    });
+  }
+
+  private isValueRegistration(
+    registration: CodemationContainerRegistration<unknown>,
+  ): registration is CodemationValueRegistration<unknown> {
+    return "useValue" in registration;
+  }
+
+  private isClassRegistration(
+    registration: CodemationContainerRegistration<unknown>,
+  ): registration is CodemationClassRegistration<unknown> {
+    return "useClass" in registration;
+  }
+}

package/src/bootstrap/CodemationFrontendBootstrapRequest.ts

@@ -0,0 +1,16 @@
+import { CodemationBootstrapRequest } from "./CodemationBootstrapRequest";
+
+export class CodemationFrontendBootstrapRequest {
+  readonly bootstrap: CodemationBootstrapRequest;
+  readonly skipPresentationServers: boolean;
+
+  constructor(
+    args: Readonly<{
+      bootstrap: CodemationBootstrapRequest;
+      skipPresentationServers?: boolean;
+    }>,
+  ) {
+    this.bootstrap = args.bootstrap;
+    this.skipPresentationServers = args.skipPresentationServers ?? false;
+  }
+}

package/src/bootstrap/CodemationWorkerBootstrapRequest.ts

@@ -0,0 +1,19 @@
+import { CodemationBootstrapRequest } from "./CodemationBootstrapRequest";
+
+export class CodemationWorkerBootstrapRequest {
+  readonly bootstrap: CodemationBootstrapRequest;
+  readonly queues: ReadonlyArray<string>;
+  readonly bootstrapSource?: string | null;
+
+  constructor(
+    args: Readonly<{
+      bootstrap: CodemationBootstrapRequest;
+      queues: ReadonlyArray<string>;
+      bootstrapSource?: string | null;
+    }>,
+  ) {
+    this.bootstrap = args.bootstrap;
+    this.queues = [...args.queues];
+    this.bootstrapSource = args.bootstrapSource;
+  }
+}

package/src/bootstrap/PreparedCodemationRuntime.ts

@@ -0,0 +1,37 @@
+import type { PGlite } from "@electric-sql/pglite";
+import type { Container } from "@codemation/core";
+import { Engine } from "@codemation/core/bootstrap";
+import { WorkflowRunEventWebsocketRelay } from "../application/websocket/WorkflowRunEventWebsocketRelay";
+import type { BootRuntimeSummary } from "../application/dev/BootRuntimeSummary.types";
+import type { PrismaClient } from "../infrastructure/persistence/generated/prisma-client/client.js";
+import { WorkflowWebsocketServer } from "../presentation/websocket/WorkflowWebsocketServer";
+import type { ResolvedImplementationSelection } from "./runtime/ResolvedImplementationSelectionFactory";
+
+export class PreparedCodemationRuntime {
+  constructor(
+    readonly container: Container,
+    readonly runtimeSummary: BootRuntimeSummary,
+    readonly implementationSelection: ResolvedImplementationSelection,
+    readonly usesProvidedPrismaClientOverride: boolean,
+    private readonly ownedPrismaClient: PrismaClient | null,
+    private readonly ownedPglite: PGlite | null,
+  ) {}
+
+  async stop(args?: Readonly<{ stopWebsocketServer?: boolean }>): Promise<void> {
+    if (this.container.isRegistered(Engine, true)) {
+      await this.container.resolve(Engine).stop();
+    }
+    if (this.container.isRegistered(WorkflowRunEventWebsocketRelay, true)) {
+      await this.container.resolve(WorkflowRunEventWebsocketRelay).stop();
+    }
+    if (args?.stopWebsocketServer !== false && this.container.isRegistered(WorkflowWebsocketServer, true)) {
+      await this.container.resolve(WorkflowWebsocketServer).stop();
+    }
+    if (this.ownedPrismaClient) {
+      await this.ownedPrismaClient.$disconnect();
+    }
+    if (this.ownedPglite) {
+      await this.ownedPglite.close();
+    }
+  }
+}

package/src/bootstrap/PreparedCodemationRuntimeFactory.ts

@@ -0,0 +1,308 @@
+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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,86 @@
+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

@@ -0,0 +1,64 @@
+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/AppConfigFactory.ts

@@ -0,0 +1,57 @@
+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";
+
+export class AppConfigFactory {
+  constructor(
+    private readonly implementationSelectionFactory: ResolvedImplementationSelectionFactory = new ResolvedImplementationSelectionFactory(),
+  ) {}
+
+  create(
+    args: Readonly<{
+      repoRoot: string;
+      consumerRoot: string;
+      env: NodeJS.ProcessEnv;
+      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;
+
+    return {
+      consumerRoot: args.consumerRoot,
+      repoRoot: args.repoRoot,
+      env: args.env,
+      workflowSources: [...args.workflowSources],
+      databaseUrl,
+      database: args.runtimeConfig.database,
+      scheduler: {
+        kind: selection.schedulerKind,
+        queuePrefix,
+        workerQueues,
+        redisUrl: selection.redisUrl,
+      },
+      eventing: {
+        kind: selection.eventBusKind,
+        queuePrefix,
+        redisUrl: selection.redisUrl,
+      },
+      auth: args.authConfig,
+      whitelabel: args.whitelabelConfig,
+    };
+  }
+}