@codemation/host 0.0.1

package/src/application/websocket/WorkflowRunEventWebsocketRelay.ts

@@ -0,0 +1,36 @@
+import type { RunEventBus, RunEventSubscription } from "@codemation/core";
+import { CoreTokens, inject, injectable } from "@codemation/core";
+import { ApplicationTokens } from "../../applicationTokens";
+import type { WorkflowWebsocketPublisher } from "./WorkflowWebsocketPublisher";
+
+@injectable()
+export class WorkflowRunEventWebsocketRelay {
+  private subscription: RunEventSubscription | null = null;
+
+  constructor(
+    @inject(ApplicationTokens.WorkflowWebsocketPublisher)
+    private readonly workflowWebsocketPublisher: WorkflowWebsocketPublisher,
+    @inject(CoreTokens.RunEventBus)
+    private readonly runEventBus: RunEventBus,
+  ) {}
+
+  async start(): Promise<void> {
+    if (this.subscription) {
+      return;
+    }
+    this.subscription = await this.runEventBus.subscribe(async (event) => {
+      await this.workflowWebsocketPublisher.publishToRoom(event.workflowId, {
+        kind: "event",
+        event,
+      });
+    });
+  }
+
+  async stop(): Promise<void> {
+    if (!this.subscription) {
+      return;
+    }
+    await this.subscription.close();
+    this.subscription = null;
+  }
+}

package/src/application/websocket/WorkflowWebsocketPublisher.ts

@@ -0,0 +1,5 @@
+import type { WorkflowWebsocketMessage } from "../contracts/WorkflowWebsocketMessage";
+
+export interface WorkflowWebsocketPublisher {
+  publishToRoom(roomId: string, message: WorkflowWebsocketMessage): Promise<void>;
+}

package/src/application/workflows/WebhookEndpointPathValidator.ts

@@ -0,0 +1,35 @@
+import type { WorkflowDefinition } from "@codemation/core";
+import { inject, injectable } from "@codemation/core";
+import type { LoggerFactory } from "../logging/Logger";
+import { ApplicationTokens } from "../../applicationTokens";
+
+@injectable()
+export class WebhookEndpointPathValidator {
+  constructor(@inject(ApplicationTokens.LoggerFactory) private readonly loggerFactory: LoggerFactory) {}
+
+  validateAndWarn(workflows: ReadonlyArray<WorkflowDefinition>): void {
+    const logger = this.loggerFactory.create("codemation.webhooks.path");
+    for (const wf of workflows) {
+      for (const node of wf.nodes) {
+        if (node.kind !== "trigger") {
+          continue;
+        }
+        const cfg = node.config as { endpointKey?: unknown };
+        if (typeof cfg.endpointKey !== "string") {
+          continue;
+        }
+        const path = cfg.endpointKey;
+        if (path.includes(".")) {
+          logger.warn(
+            `Webhook endpoint path "${path}" in workflow "${wf.id}" contains a dot; use a stable URL segment without dots for predictable routing.`,
+          );
+        }
+        if (path.includes("/")) {
+          logger.warn(
+            `Webhook endpoint path "${path}" in workflow "${wf.id}" contains "/"; use a single URL segment (no slashes).`,
+          );
+        }
+      }
+    }
+  }
+}

package/src/application/workflows/WorkflowDebuggerOverlayStateFactory.ts

@@ -0,0 +1,122 @@
+import type { PersistedRunState, RunCurrentState } from "@codemation/core";
+import type { WorkflowDebuggerOverlayState } from "../../domain/workflows/WorkflowDebuggerOverlayState";
+
+export class WorkflowDebuggerOverlayStateFactory {
+  static createEmpty(workflowId: string): WorkflowDebuggerOverlayState {
+    return {
+      workflowId,
+      updatedAt: new Date().toISOString(),
+      currentState: {
+        outputsByNode: {},
+        nodeSnapshotsByNodeId: {},
+        connectionInvocations: [],
+        mutableState: {
+          nodesById: {},
+        },
+      },
+    };
+  }
+
+  static replaceCurrentState(
+    args: Readonly<{
+      workflowId: string;
+      currentState?: RunCurrentState;
+      copiedFromRunId?: string;
+      updatedAt?: string;
+    }>,
+  ): WorkflowDebuggerOverlayState {
+    return {
+      workflowId: args.workflowId,
+      updatedAt: args.updatedAt ?? new Date().toISOString(),
+      copiedFromRunId: args.copiedFromRunId,
+      currentState: this.cloneCurrentState(args.currentState),
+    };
+  }
+
+  static copyRunStateToOverlay(
+    args: Readonly<{
+      workflowId: string;
+      sourceState: PersistedRunState;
+      liveWorkflowNodeIds: ReadonlySet<string>;
+      existingOverlay?: WorkflowDebuggerOverlayState;
+    }>,
+  ): WorkflowDebuggerOverlayState {
+    const existingState = this.cloneCurrentState(args.existingOverlay?.currentState);
+    const filteredOutputsByNode: RunCurrentState["outputsByNode"] = { ...existingState.outputsByNode };
+    const filteredSnapshotsByNodeId: RunCurrentState["nodeSnapshotsByNodeId"] = {
+      ...existingState.nodeSnapshotsByNodeId,
+    };
+    const filteredMutableNodesById = { ...(existingState.mutableState?.nodesById ?? {}) };
+    const filteredConnectionInvocations = (args.sourceState.connectionInvocations ?? []).filter(
+      (inv) =>
+        args.liveWorkflowNodeIds.has(inv.connectionNodeId) || args.liveWorkflowNodeIds.has(inv.parentAgentNodeId),
+    );
+
+    for (const nodeId of args.liveWorkflowNodeIds) {
+      const nodeOutputs = args.sourceState.outputsByNode[nodeId];
+      const nodeSnapshot = args.sourceState.nodeSnapshotsByNodeId[nodeId];
+      if (nodeOutputs) {
+        filteredOutputsByNode[nodeId] = JSON.parse(
+          JSON.stringify(nodeOutputs),
+        ) as RunCurrentState["outputsByNode"][string];
+      } else {
+        delete filteredOutputsByNode[nodeId];
+      }
+      if (nodeSnapshot) {
+        filteredSnapshotsByNodeId[nodeId] = JSON.parse(
+          JSON.stringify(nodeSnapshot),
+        ) as RunCurrentState["nodeSnapshotsByNodeId"][string];
+      } else {
+        delete filteredSnapshotsByNodeId[nodeId];
+      }
+      filteredMutableNodesById[nodeId] = {
+        ...(filteredMutableNodesById[nodeId] ?? {}),
+        pinnedOutputsByPort: undefined,
+      };
+    }
+    return {
+      workflowId: args.workflowId,
+      updatedAt: new Date().toISOString(),
+      copiedFromRunId: args.sourceState.runId,
+      currentState: {
+        outputsByNode: filteredOutputsByNode,
+        nodeSnapshotsByNodeId: filteredSnapshotsByNodeId,
+        connectionInvocations: filteredConnectionInvocations.map((inv) => JSON.parse(JSON.stringify(inv))),
+        mutableState: {
+          nodesById: filteredMutableNodesById,
+        },
+      },
+    };
+  }
+
+  static cloneCurrentState(currentState: RunCurrentState | undefined): RunCurrentState {
+    if (!currentState) {
+      return {
+        outputsByNode: {},
+        nodeSnapshotsByNodeId: {},
+        connectionInvocations: [],
+        mutableState: {
+          nodesById: {},
+        },
+      };
+    }
+    return {
+      outputsByNode: JSON.parse(JSON.stringify(currentState.outputsByNode ?? {})) as RunCurrentState["outputsByNode"],
+      nodeSnapshotsByNodeId: JSON.parse(
+        JSON.stringify(currentState.nodeSnapshotsByNodeId ?? {}),
+      ) as RunCurrentState["nodeSnapshotsByNodeId"],
+      connectionInvocations: currentState.connectionInvocations
+        ? (JSON.parse(JSON.stringify(currentState.connectionInvocations)) as NonNullable<
+            RunCurrentState["connectionInvocations"]
+          >)
+        : undefined,
+      mutableState: JSON.parse(
+        JSON.stringify(
+          currentState.mutableState ?? {
+            nodesById: {},
+          },
+        ),
+      ) as NonNullable<RunCurrentState["mutableState"]>,
+    };
+  }
+}

package/src/applicationTokens.ts

@@ -0,0 +1,72 @@
+import type { Clock, TypeToken } from "@codemation/core";
+import type { SessionVerifier } from "./application/auth/SessionVerifier";
+import type { Command } from "./application/bus/Command";
+import type { CommandBus } from "./application/bus/CommandBus";
+import type { CommandHandler } from "./application/bus/CommandHandler";
+import type { DomainEvent } from "./application/bus/DomainEvent";
+import type { DomainEventBus } from "./application/bus/DomainEventBus";
+import type { DomainEventHandler } from "./application/bus/DomainEventHandler";
+import type { Query } from "./application/bus/Query";
+import type { QueryBus } from "./application/bus/QueryBus";
+import type { QueryHandler } from "./application/bus/QueryHandler";
+import type { Logger, LoggerFactory } from "./application/logging/Logger";
+import type { WorkflowWebsocketPublisher } from "./application/websocket/WorkflowWebsocketPublisher";
+import type { CredentialStore } from "./domain/credentials/CredentialServices";
+import type { WorkflowRunRepository } from "./domain/runs/WorkflowRunRepository";
+import type { WorkflowDebuggerOverlayRepository } from "./domain/workflows/WorkflowDebuggerOverlayRepository";
+import type { WorkflowDefinitionRepository } from "./domain/workflows/WorkflowDefinitionRepository";
+import type { WorkflowActivationRepository } from "./domain/workflows/WorkflowActivationRepository";
+import type { WorkerRuntimeScheduler } from "./infrastructure/runtime/WorkerRuntimeScheduler";
+import type { PrismaClient } from "./infrastructure/persistence/generated/prisma-client/client.js";
+import type { AppConfig } from "./presentation/config/AppConfig";
+import type { CodemationAuthConfig } from "./presentation/config/CodemationAuthConfig";
+import type { CodemationWhitelabelConfig } from "./presentation/config/CodemationWhitelabelConfig";
+import type { HonoApiRouteRegistrar } from "./presentation/http/hono/HonoApiRouteRegistrar";
+
+export const ApplicationTokens = {
+  CodemationAuthConfig: Symbol.for("codemation.application.CodemationAuthConfig") as TypeToken<
+    CodemationAuthConfig | undefined
+  >,
+  CodemationWhitelabelConfig: Symbol.for(
+    "codemation.application.CodemationWhitelabelConfig",
+  ) as TypeToken<CodemationWhitelabelConfig>,
+  AppConfig: Symbol.for("codemation.application.AppConfig") as TypeToken<AppConfig>,
+  WebSocketPort: Symbol.for("codemation.application.WebSocketPort") as TypeToken<number>,
+  WebSocketBindHost: Symbol.for("codemation.application.WebSocketBindHost") as TypeToken<string>,
+  QueryBus: Symbol.for("codemation.application.QueryBus") as TypeToken<QueryBus>,
+  CommandBus: Symbol.for("codemation.application.CommandBus") as TypeToken<CommandBus>,
+  DomainEventBus: Symbol.for("codemation.application.DomainEventBus") as TypeToken<DomainEventBus>,
+  QueryHandler: Symbol.for("codemation.application.QueryHandler") as TypeToken<QueryHandler<Query<unknown>, unknown>>,
+  CommandHandler: Symbol.for("codemation.application.CommandHandler") as TypeToken<
+    CommandHandler<Command<unknown>, unknown>
+  >,
+  DomainEventHandler: Symbol.for("codemation.application.DomainEventHandler") as TypeToken<
+    DomainEventHandler<DomainEvent>
+  >,
+  HonoApiRouteRegistrar: Symbol.for("codemation.application.HonoApiRouteRegistrar") as TypeToken<HonoApiRouteRegistrar>,
+  WorkflowWebsocketPublisher: Symbol.for(
+    "codemation.application.WorkflowWebsocketPublisher",
+  ) as TypeToken<WorkflowWebsocketPublisher>,
+  WorkerRuntimeScheduler: Symbol.for(
+    "codemation.application.WorkerRuntimeScheduler",
+  ) as TypeToken<WorkerRuntimeScheduler>,
+  WorkflowDefinitionRepository: Symbol.for(
+    "codemation.application.WorkflowDefinitionRepository",
+  ) as TypeToken<WorkflowDefinitionRepository>,
+  WorkflowActivationRepository: Symbol.for(
+    "codemation.application.WorkflowActivationRepository",
+  ) as TypeToken<WorkflowActivationRepository>,
+  WorkflowDebuggerOverlayRepository: Symbol.for(
+    "codemation.application.WorkflowDebuggerOverlayRepository",
+  ) as TypeToken<WorkflowDebuggerOverlayRepository>,
+  WorkflowRunRepository: Symbol.for("codemation.application.WorkflowRunRepository") as TypeToken<WorkflowRunRepository>,
+  LoggerFactory: Symbol.for("codemation.application.LoggerFactory") as TypeToken<LoggerFactory>,
+  /**
+   * Opt-in timing/diagnostics logger (`CODEMATION_PERFORMANCE_LOGGING` + normal minimum log level).
+   */
+  PerformanceDiagnosticsLogger: Symbol.for("codemation.application.PerformanceDiagnosticsLogger") as TypeToken<Logger>,
+  CredentialStore: Symbol.for("codemation.application.CredentialStore") as TypeToken<CredentialStore>,
+  PrismaClient: Symbol.for("codemation.application.PrismaClient") as TypeToken<PrismaClient>,
+  SessionVerifier: Symbol.for("codemation.application.SessionVerifier") as TypeToken<SessionVerifier>,
+  Clock: Symbol.for("codemation.application.Clock") as TypeToken<Clock>,
+} as const;

package/src/bootstrap/CodemationBootstrapRequest.ts

@@ -0,0 +1,27 @@
+export class CodemationBootstrapRequest {
+  readonly consumerRoot: string;
+  readonly repoRoot: string;
+  readonly workflowSources: ReadonlyArray<string>;
+  readonly env?: Readonly<NodeJS.ProcessEnv>;
+
+  constructor(
+    args: Readonly<{
+      consumerRoot: string;
+      repoRoot: string;
+      workflowSources?: ReadonlyArray<string>;
+      env?: Readonly<NodeJS.ProcessEnv>;
+    }>,
+  ) {
+    this.consumerRoot = args.consumerRoot;
+    this.repoRoot = args.repoRoot;
+    this.workflowSources = [...(args.workflowSources ?? [])];
+    this.env = args.env;
+  }
+
+  resolveEnvironment(): NodeJS.ProcessEnv {
+    return {
+      ...process.env,
+      ...(this.env ?? {}),
+    };
+  }
+}

package/src/bootstrap/CodemationContainerFactory.ts

@@ -0,0 +1,310 @@
+import "reflect-metadata";
+
+import type { Container, WorkflowDefinition } from "@codemation/core";
+import { CoreTokens, instanceCachingFactory, container as tsyringeContainer } from "@codemation/core";
+import {
+  EngineRuntimeRegistrar,
+  PersistedWorkflowTokenRegistry,
+  WorkflowRepositoryWebhookTriggerMatcher,
+} from "@codemation/core/bootstrap";
+import { AIAgentConnectionWorkflowExpander, ConnectionCredentialNodeConfigFactory } from "@codemation/core-nodes";
+import { WorkflowRunEventWebsocketRelay } from "../application/websocket/WorkflowRunEventWebsocketRelay";
+import { ApplicationTokens } from "../applicationTokens";
+import { CodemationApplication } from "../codemationApplication";
+import type { CredentialType } from "../domain/credentials/CredentialServices";
+import {
+  CredentialBindingService,
+  CredentialFieldEnvOverlayService,
+  CredentialInstanceService,
+  CredentialMaterialResolver,
+  CredentialRuntimeMaterialService,
+  CredentialSecretCipher,
+  CredentialSessionServiceImpl,
+  CredentialTestService,
+  CredentialTypeRegistryImpl,
+} from "../domain/credentials/CredentialServices";
+import { OAuth2ConnectService } from "../domain/credentials/OAuth2ConnectServiceFactory";
+import { OAuth2ProviderRegistry } from "../domain/credentials/OAuth2ProviderRegistry";
+import { WorkflowCredentialNodeResolver } from "../domain/credentials/WorkflowCredentialNodeResolver";
+import { UserAccountService } from "../domain/users/UserAccountServiceRegistry";
+import type { WorkflowDebuggerOverlayRepository } from "../domain/workflows/WorkflowDebuggerOverlayRepository";
+import type { WorkflowDefinitionRepository } from "../domain/workflows/WorkflowDefinitionRepository";
+import type { WorkflowRunRepository } from "../domain/runs/WorkflowRunRepository";
+import { WorkflowActivationPreflight } from "../domain/workflows/WorkflowActivationPreflight";
+import { WorkflowActivationPreflightRules } from "../domain/workflows/WorkflowActivationPreflightRules";
+import { BootRuntimeSnapshotHolder } from "../application/dev/BootRuntimeSnapshotHolder";
+import { DevBootstrapSummaryAssembler } from "../application/dev/DevBootstrapSummaryAssembler";
+import { WorkflowDefinitionMapper } from "../application/mapping/WorkflowDefinitionMapper";
+import { WorkflowPolicyUiPresentationFactory } from "../application/mapping/WorkflowPolicyUiPresentationFactory";
+import { WorkflowWebsocketServer } from "../presentation/websocket/WorkflowWebsocketServer";
+import { DevBootstrapSummaryHttpRouteHandler } from "../presentation/http/routeHandlers/DevBootstrapSummaryHttpRouteHandler";
+import { WhitelabelLogoHttpRouteHandler } from "../presentation/http/routeHandlers/WhitelabelLogoHttpRouteHandler";
+import { CodemationHonoApiApp } from "../presentation/http/hono/CodemationHonoApiAppFactory";
+import { RequestToWebhookItemMapper } from "../infrastructure/webhooks/RequestToWebhookItemMapper";
+import { WebhookEndpointPathValidator } from "../application/workflows/WebhookEndpointPathValidator";
+import { CodemationIdFactory } from "../infrastructure/ids/CodemationIdFactory";
+import { InMemoryCommandBus } from "../infrastructure/di/InMemoryCommandBus";
+import { InMemoryDomainEventBus } from "../infrastructure/di/InMemoryDomainEventBus";
+import { InMemoryQueryBus } from "../infrastructure/di/InMemoryQueryBus";
+import { AuthJsSessionVerifier } from "../infrastructure/auth/AuthJsSessionVerifier";
+import { DevelopmentSessionBypassVerifier } from "../infrastructure/auth/DevelopmentSessionBypassVerifier";
+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 { PrismaMigrationDeployer } from "../infrastructure/persistence/PrismaMigrationDeployer";
+import { PrismaTriggerSetupStateRepository } from "../infrastructure/persistence/PrismaTriggerSetupStateRepository";
+import { PrismaWorkflowActivationRepository } from "../infrastructure/persistence/PrismaWorkflowActivationRepository";
+import { PrismaWorkflowDebuggerOverlayRepository } from "../infrastructure/persistence/PrismaWorkflowDebuggerOverlayRepository";
+import { RuntimeWorkflowActivationPolicy } from "../infrastructure/persistence/RuntimeWorkflowActivationPolicy";
+import { WorkflowDefinitionRepositoryAdapter } from "../infrastructure/persistence/WorkflowDefinitionRepositoryAdapter";
+import { WorkflowRunRepository as SqlWorkflowRunRepository } from "../infrastructure/persistence/WorkflowRunRepository";
+import { LiveWorkflowRepository } from "../infrastructure/runtime/LiveWorkflowRepository";
+import { LogLevelPolicyFactory, logLevelPolicyFactory } from "../infrastructure/logging/LogLevelPolicyFactory";
+import { ServerLoggerFactory } from "../infrastructure/logging/ServerLoggerFactory";
+import type { AppConfig } from "../presentation/config/AppConfig";
+import type { CodemationApplicationRuntimeConfig } from "../presentation/config/CodemationConfig";
+import type { CodemationContainerRegistration } from "./CodemationContainerRegistration";
+import { CodemationContainerRegistrationRegistrar } from "./CodemationContainerRegistrationRegistrar";
+
+type CodemationContainerState = Readonly<{
+  application: CodemationApplication;
+  registrations: ReadonlyArray<CodemationContainerRegistration<unknown>>;
+  runtimeConfig: CodemationApplicationRuntimeConfig;
+  workflows: ReadonlyArray<WorkflowDefinition>;
+  credentialTypes: ReadonlyArray<CredentialType<any, any, unknown>>;
+  sharedWorkflowWebsocketServer: WorkflowWebsocketServer | null;
+}>;
+
+export class CodemationContainerFactory {
+  constructor(
+    private readonly containerRegistrationRegistrar: CodemationContainerRegistrationRegistrar = new CodemationContainerRegistrationRegistrar(),
+  ) {}
+
+  create(state: CodemationContainerState): Container {
+    const container = tsyringeContainer.createChildContainer();
+    this.registerCoreInfrastructure(container, state);
+    this.registerRepositoriesAndBuses(container);
+    this.registerApplicationServicesAndRoutes(container);
+    this.registerOperationalInfrastructure(container);
+    this.registerConfiguredRegistrations(container, state.registrations);
+    this.registerCredentialTypes(container, state.credentialTypes);
+    this.synchronizeLiveWorkflowRepository(container, state.workflows);
+    return container;
+  }
+
+  private registerCredentialTypes(
+    container: Container,
+    credentialTypes: ReadonlyArray<CredentialType<any, any, unknown>>,
+  ): void {
+    const registry = container.resolve(CredentialTypeRegistryImpl);
+    for (const credentialType of credentialTypes) {
+      registry.register(credentialType);
+    }
+  }
+
+  private registerConfiguredRegistrations(
+    container: Container,
+    registrations: ReadonlyArray<CodemationContainerRegistration<unknown>>,
+  ): void {
+    if (registrations.length === 0) {
+      return;
+    }
+    this.containerRegistrationRegistrar.apply(container, registrations);
+  }
+
+  private registerCoreInfrastructure(container: Container, state: CodemationContainerState): void {
+    container.registerInstance(BootRuntimeSnapshotHolder, new BootRuntimeSnapshotHolder());
+    container.registerInstance(CodemationApplication, state.application);
+    container.registerInstance(CoreTokens.PersistedWorkflowTokenRegistry, new PersistedWorkflowTokenRegistry());
+    container.register(CredentialTypeRegistryImpl, {
+      useFactory: instanceCachingFactory(() => new CredentialTypeRegistryImpl()),
+    });
+    container.register(CoreTokens.CredentialTypeRegistry, {
+      useFactory: instanceCachingFactory((dependencyContainer) =>
+        dependencyContainer.resolve(CredentialTypeRegistryImpl),
+      ),
+    });
+    container.register(CodemationIdFactory, { useClass: CodemationIdFactory });
+    container.register(CoreTokens.RunIdFactory, {
+      useFactory: instanceCachingFactory((dependencyContainer) => dependencyContainer.resolve(CodemationIdFactory)),
+    });
+    container.register(CoreTokens.ActivationIdFactory, {
+      useFactory: instanceCachingFactory((dependencyContainer) => dependencyContainer.resolve(CodemationIdFactory)),
+    });
+    container.register(CoreTokens.LiveWorkflowRepository, {
+      useFactory: instanceCachingFactory(
+        () =>
+          new LiveWorkflowRepository(
+            new AIAgentConnectionWorkflowExpander(new ConnectionCredentialNodeConfigFactory()),
+          ),
+      ),
+    });
+    container.register(CoreTokens.WorkflowRepository, {
+      useFactory: instanceCachingFactory((dependencyContainer) =>
+        dependencyContainer.resolve(CoreTokens.LiveWorkflowRepository),
+      ),
+    });
+    container.registerInstance(CoreTokens.NodeResolver, container);
+    const runtimeWorkflowActivationPolicy = new RuntimeWorkflowActivationPolicy();
+    container.registerInstance(RuntimeWorkflowActivationPolicy, runtimeWorkflowActivationPolicy);
+    container.registerInstance(CoreTokens.WorkflowActivationPolicy, runtimeWorkflowActivationPolicy);
+    new EngineRuntimeRegistrar().register(container, {
+      resolveEngineExecutionLimits: () => state.runtimeConfig.engineExecutionLimits,
+      webhookTriggerMatcherProvider: {
+        createMatcher: (dependencyContainer) => {
+          const serverLoggerFactory = dependencyContainer.resolve(ServerLoggerFactory);
+          const webhookRoutingLogger = serverLoggerFactory.create("codemation.webhooks.routing");
+          return new WorkflowRepositoryWebhookTriggerMatcher(
+            dependencyContainer.resolve(CoreTokens.WorkflowRepository),
+            dependencyContainer.resolve(CoreTokens.WorkflowActivationPolicy),
+            {
+              warn: (message) => webhookRoutingLogger.warn(message),
+              info: (message) => webhookRoutingLogger.debug(message),
+            },
+          );
+        },
+      },
+      triggerRuntimeDiagnosticsProvider: {
+        create: (dependencyContainer) => {
+          const triggerRuntimeLogger = dependencyContainer
+            .resolve(ServerLoggerFactory)
+            .create("codemation.engine.triggers");
+          return {
+            info: (message) => triggerRuntimeLogger.debug(message),
+            warn: (message) => triggerRuntimeLogger.warn(message),
+          };
+        },
+      },
+    });
+    container.registerInstance(LogLevelPolicyFactory, logLevelPolicyFactory);
+    container.register(ServerLoggerFactory, { useClass: ServerLoggerFactory });
+    container.register(ApplicationTokens.LoggerFactory, {
+      useFactory: instanceCachingFactory((dependencyContainer) => dependencyContainer.resolve(ServerLoggerFactory)),
+    });
+    container.register(ApplicationTokens.PerformanceDiagnosticsLogger, {
+      useFactory: instanceCachingFactory((dependencyContainer) =>
+        dependencyContainer.resolve(ServerLoggerFactory).createPerformanceDiagnostics("codemation.performance"),
+      ),
+    });
+    container.register(WorkflowWebsocketServer, {
+      useFactory: instanceCachingFactory((dependencyContainer) => {
+        if (state.sharedWorkflowWebsocketServer) {
+          return state.sharedWorkflowWebsocketServer;
+        }
+        return new WorkflowWebsocketServer(
+          dependencyContainer.resolve(ApplicationTokens.WebSocketPort),
+          dependencyContainer.resolve(ApplicationTokens.WebSocketBindHost),
+          dependencyContainer.resolve(ServerLoggerFactory).create("codemation-websocket.server"),
+        );
+      }),
+    });
+    container.register(PrismaClientFactory, { useClass: PrismaClientFactory });
+    container.register(PrismaMigrationDeployer, { useClass: PrismaMigrationDeployer });
+    container.register(WorkflowPolicyUiPresentationFactory, { useClass: WorkflowPolicyUiPresentationFactory });
+    container.register(WorkflowDefinitionMapper, { useClass: WorkflowDefinitionMapper });
+    container.register(RequestToWebhookItemMapper, { useClass: RequestToWebhookItemMapper });
+    container.register(WebhookEndpointPathValidator, { useClass: WebhookEndpointPathValidator });
+    container.register(CredentialSecretCipher, { useClass: CredentialSecretCipher });
+    container.register(CredentialMaterialResolver, { useClass: CredentialMaterialResolver });
+    container.register(CredentialFieldEnvOverlayService, { useClass: CredentialFieldEnvOverlayService });
+    container.register(CredentialRuntimeMaterialService, { useClass: CredentialRuntimeMaterialService });
+    container.register(WorkflowCredentialNodeResolver, { useClass: WorkflowCredentialNodeResolver });
+    container.register(CredentialInstanceService, { useClass: CredentialInstanceService });
+    container.register(CredentialBindingService, { useClass: CredentialBindingService });
+    container.register(WorkflowActivationPreflightRules, { useClass: WorkflowActivationPreflightRules });
+    container.register(WorkflowActivationPreflight, { useClass: WorkflowActivationPreflight });
+    container.register(CredentialTestService, { useClass: CredentialTestService });
+    container.register(CredentialSessionServiceImpl, { useClass: CredentialSessionServiceImpl });
+    container.register(OAuth2ProviderRegistry, { useClass: OAuth2ProviderRegistry });
+    container.register(OAuth2ConnectService, { useClass: OAuth2ConnectService });
+    container.register(DevelopmentSessionBypassVerifier, { useClass: DevelopmentSessionBypassVerifier });
+    container.register(AuthJsSessionVerifier, {
+      useFactory: instanceCachingFactory((dependencyContainer) => {
+        const appConfig = dependencyContainer.resolve<AppConfig>(ApplicationTokens.AppConfig);
+        return new AuthJsSessionVerifier(appConfig.env.AUTH_SECRET ?? "");
+      }),
+    });
+    container.register(UserAccountService, { useClass: UserAccountService });
+  }
+
+  private registerRepositoriesAndBuses(container: Container): void {
+    container.register(WorkflowDefinitionRepositoryAdapter, { useClass: WorkflowDefinitionRepositoryAdapter });
+    container.register(InMemoryWorkflowRunRepository, { useClass: InMemoryWorkflowRunRepository });
+    container.register(InMemoryTriggerSetupStateRepository, { useClass: InMemoryTriggerSetupStateRepository });
+    container.register(InMemoryCredentialStore, { useClass: InMemoryCredentialStore });
+    container.register(SqlWorkflowRunRepository, { useClass: SqlWorkflowRunRepository });
+    container.register(InMemoryWorkflowDebuggerOverlayRepository, {
+      useClass: InMemoryWorkflowDebuggerOverlayRepository,
+    });
+    container.register(PrismaTriggerSetupStateRepository, { useClass: PrismaTriggerSetupStateRepository });
+    container.register(PrismaWorkflowDebuggerOverlayRepository, {
+      useClass: PrismaWorkflowDebuggerOverlayRepository,
+    });
+    container.register(PrismaWorkflowActivationRepository, { useClass: PrismaWorkflowActivationRepository });
+    container.register(InMemoryWorkflowActivationRepository, { useClass: InMemoryWorkflowActivationRepository });
+    container.register(PrismaCredentialStore, { useClass: PrismaCredentialStore });
+    container.register(ApplicationTokens.WorkflowDefinitionRepository, {
+      useFactory: instanceCachingFactory(
+        (dependencyContainer) =>
+          dependencyContainer.resolve(WorkflowDefinitionRepositoryAdapter) as unknown as WorkflowDefinitionRepository,
+      ),
+    });
+    container.register(ApplicationTokens.WorkflowRunRepository, {
+      useFactory: instanceCachingFactory(
+        (dependencyContainer) =>
+          dependencyContainer.resolve(SqlWorkflowRunRepository) as unknown as WorkflowRunRepository,
+      ),
+    });
+    container.register(ApplicationTokens.WorkflowDebuggerOverlayRepository, {
+      useFactory: instanceCachingFactory(
+        (dependencyContainer) =>
+          dependencyContainer.resolve(
+            InMemoryWorkflowDebuggerOverlayRepository,
+          ) as unknown as WorkflowDebuggerOverlayRepository,
+      ),
+    });
+    container.register(ApplicationTokens.CredentialStore, {
+      useFactory: instanceCachingFactory((dependencyContainer) => dependencyContainer.resolve(InMemoryCredentialStore)),
+    });
+    container.register(InMemoryQueryBus, { useClass: InMemoryQueryBus });
+    container.register(InMemoryCommandBus, { useClass: InMemoryCommandBus });
+    container.register(InMemoryDomainEventBus, { useClass: InMemoryDomainEventBus });
+    container.register(ApplicationTokens.QueryBus, {
+      useFactory: instanceCachingFactory((dependencyContainer) => dependencyContainer.resolve(InMemoryQueryBus)),
+    });
+    container.register(ApplicationTokens.CommandBus, {
+      useFactory: instanceCachingFactory((dependencyContainer) => dependencyContainer.resolve(InMemoryCommandBus)),
+    });
+    container.register(ApplicationTokens.DomainEventBus, {
+      useFactory: instanceCachingFactory((dependencyContainer) => dependencyContainer.resolve(InMemoryDomainEventBus)),
+    });
+  }
+
+  private registerApplicationServicesAndRoutes(container: Container): void {
+    container.register(DevBootstrapSummaryAssembler, { useClass: DevBootstrapSummaryAssembler });
+    container.register(DevBootstrapSummaryHttpRouteHandler, { useClass: DevBootstrapSummaryHttpRouteHandler });
+    container.register(WhitelabelLogoHttpRouteHandler, { useClass: WhitelabelLogoHttpRouteHandler });
+    container.register(CodemationHonoApiApp, { useClass: CodemationHonoApiApp });
+  }
+
+  private registerOperationalInfrastructure(container: Container): void {
+    container.register(ApplicationTokens.WorkflowWebsocketPublisher, {
+      useFactory: instanceCachingFactory((dependencyContainer) => dependencyContainer.resolve(WorkflowWebsocketServer)),
+    });
+    container.register(WorkflowRunEventWebsocketRelay, { useClass: WorkflowRunEventWebsocketRelay });
+  }
+
+  private synchronizeLiveWorkflowRepository(container: Container, workflows: ReadonlyArray<WorkflowDefinition>): void {
+    const liveWorkflowRepository = container.resolve(CoreTokens.LiveWorkflowRepository);
+    liveWorkflowRepository.setWorkflows(workflows);
+    if (container.isRegistered(WebhookEndpointPathValidator, true)) {
+      container.resolve(WebhookEndpointPathValidator).validateAndWarn(workflows);
+    }
+  }
+}

package/src/bootstrap/CodemationContainerRegistration.ts

@@ -0,0 +1,23 @@
+import type { Container, TypeToken } from "@codemation/core";
+import type { CodemationClassToken } from "../presentation/config/CodemationClassToken";
+
+interface CodemationContainerRegistrationBase<TValue> {
+  readonly token: TypeToken<TValue>;
+}
+
+export interface CodemationValueRegistration<TValue> extends CodemationContainerRegistrationBase<TValue> {
+  readonly useValue: TValue;
+}
+
+export interface CodemationClassRegistration<TValue> extends CodemationContainerRegistrationBase<TValue> {
+  readonly useClass: CodemationClassToken<TValue>;
+}
+
+export interface CodemationFactoryRegistration<TValue> extends CodemationContainerRegistrationBase<TValue> {
+  readonly useFactory: (container: Container) => TValue;
+}
+
+export type CodemationContainerRegistration<TValue = unknown> =
+  | CodemationValueRegistration<TValue>
+  | CodemationClassRegistration<TValue>
+  | CodemationFactoryRegistration<TValue>;