@codemation/host 0.0.1

package/src/infrastructure/persistence/PrismaMigrationDeployer.ts

@@ -0,0 +1,184 @@
+import { PGlite } from "@electric-sql/pglite";
+import { PGLiteSocketServer } from "@electric-sql/pglite-socket";
+import { injectable } from "@codemation/core";
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import type { ResolvedDatabasePersistence } from "./DatabasePersistenceResolver";
+
+/**
+ * Runs `prisma migrate deploy` against TCP PostgreSQL or against a PGlite data directory
+ * by temporarily exposing PGlite on a local Postgres protocol socket (see `@electric-sql/pglite-socket`).
+ */
+@injectable()
+export class PrismaMigrationDeployer {
+  private readonly require = createRequire(import.meta.url);
+
+  async deployPersistence(persistence: ResolvedDatabasePersistence, env?: Readonly<NodeJS.ProcessEnv>): Promise<void> {
+    if (persistence.kind === "none") {
+      return;
+    }
+    if (persistence.kind === "postgresql") {
+      await this.deployPostgres({ databaseUrl: persistence.databaseUrl, env });
+      return;
+    }
+    await this.deployPgliteViaPrismaCli({ dataDir: persistence.dataDir, env });
+  }
+
+  async deploy(args: Readonly<{ databaseUrl: string; env?: Readonly<NodeJS.ProcessEnv> }>): Promise<void> {
+    await this.deployPostgres(args);
+  }
+
+  private async deployPgliteViaPrismaCli(
+    args: Readonly<{ dataDir: string; env?: Readonly<NodeJS.ProcessEnv> }>,
+  ): Promise<void> {
+    let pglite: PGlite;
+    try {
+      pglite = new PGlite(args.dataDir);
+      await pglite.waitReady;
+    } catch (cause) {
+      throw this.createPgliteOpenFailureError(args.dataDir, cause);
+    }
+    const server = new PGLiteSocketServer({
+      db: pglite,
+      port: 0,
+      host: "127.0.0.1",
+      // Prisma migrate may use multiple connections; default maxConnections is 1.
+      maxConnections: 32,
+    });
+    await server.start();
+    try {
+      const databaseUrl = this.pgliteSocketConnectionToPostgresUrl(server.getServerConn());
+      await this.deployPostgres({ databaseUrl, env: args.env });
+    } finally {
+      await server.stop();
+      await pglite.close();
+    }
+  }
+
+  private async deployPostgres(
+    args: Readonly<{ databaseUrl: string; env?: Readonly<NodeJS.ProcessEnv> }>,
+  ): Promise<void> {
+    await new Promise<void>((resolve, reject) => {
+      const command = spawn(
+        process.execPath,
+        [this.resolvePrismaCliPath(), "migrate", "deploy", "--config", this.resolvePrismaConfigPath()],
+        {
+          cwd: this.resolvePackageRoot(),
+          env: this.createProcessEnvironment(args.databaseUrl, args.env),
+          stdio: ["ignore", "pipe", "pipe"],
+        },
+      );
+      let stdout = "";
+      let stderr = "";
+      command.stdout.on("data", (chunk: Buffer | string) => {
+        stdout += chunk.toString();
+      });
+      command.stderr.on("data", (chunk: Buffer | string) => {
+        stderr += chunk.toString();
+      });
+      command.once("error", (error) => {
+        reject(error);
+      });
+      command.once("close", (exitCode) => {
+        if (exitCode === 0) {
+          resolve();
+          return;
+        }
+        reject(this.createDeployError(exitCode, stdout, stderr));
+      });
+    });
+  }
+
+  /**
+   * {@link PGLiteSocketServer.getServerConn} returns `host:port` or a unix socket path — Prisma requires a `postgresql://` URL.
+   * The query engine expects `sslmode=disable` on this loopback socket and a user (PGlite accepts `postgres`).
+   */
+  private pgliteSocketConnectionToPostgresUrl(raw: string): string {
+    if (raw.startsWith("postgresql://") || raw.startsWith("postgres://")) {
+      return raw.includes("sslmode=") ? raw : `${raw}${raw.includes("?") ? "&" : "?"}sslmode=disable`;
+    }
+    if (raw.startsWith("/")) {
+      return `postgresql://postgres@localhost/postgres?host=${encodeURIComponent(raw)}&sslmode=disable`;
+    }
+    const colon = raw.lastIndexOf(":");
+    if (colon <= 0 || colon === raw.length - 1) {
+      throw new Error(`Unexpected PGlite socket connection string: ${raw}`);
+    }
+    const host = raw.slice(0, colon);
+    const port = raw.slice(colon + 1);
+    return `postgresql://postgres@${host}:${port}/postgres?sslmode=disable`;
+  }
+
+  private createProcessEnvironment(databaseUrl: string, env?: Readonly<NodeJS.ProcessEnv>): NodeJS.ProcessEnv {
+    return {
+      ...process.env,
+      ...(env ?? {}),
+      DATABASE_URL: databaseUrl,
+    };
+  }
+
+  private resolvePrismaCliPath(): string {
+    const configuredPath = process.env.CODEMATION_PRISMA_CLI_PATH;
+    if (configuredPath && existsSync(configuredPath)) {
+      return configuredPath;
+    }
+    const packageManagerCandidates = [
+      path.resolve(process.cwd(), "node_modules", "prisma", "build", "index.js"),
+      path.resolve(this.resolvePackageRoot(), "node_modules", "prisma", "build", "index.js"),
+    ];
+    for (const candidate of packageManagerCandidates) {
+      if (existsSync(candidate)) {
+        return candidate;
+      }
+    }
+    try {
+      return this.require.resolve("prisma/build/index.js", {
+        paths: [process.cwd(), this.resolvePackageRoot()],
+      });
+    } catch {
+      throw new Error(
+        "Unable to resolve the Prisma CLI required for startup migrations. Ensure `prisma` is installed.",
+      );
+    }
+  }
+
+  private resolvePrismaConfigPath(): string {
+    const configuredPath = process.env.CODEMATION_PRISMA_CONFIG_PATH;
+    if (configuredPath) {
+      return configuredPath;
+    }
+    return path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..", "..", "prisma.config.ts");
+  }
+
+  resolvePackageRoot(): string {
+    const configuredRoot = process.env.CODEMATION_HOST_PACKAGE_ROOT;
+    if (configuredRoot) {
+      return configuredRoot;
+    }
+    return path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..", "..");
+  }
+
+  private createPgliteOpenFailureError(dataDir: string, cause: unknown): Error {
+    const underlying = cause instanceof Error ? cause.message : String(cause);
+    return new Error(
+      [
+        `PGlite could not open "${dataDir}".`,
+        "Embedded PGlite files are sometimes left in a bad state after a crash, kill -9, or interrupted migration.",
+        "If this is a dev database you can recreate, delete that directory and run again.",
+        `Underlying error: ${underlying}`,
+      ].join(" "),
+      { cause: cause instanceof Error ? cause : undefined },
+    );
+  }
+
+  private createDeployError(exitCode: number | null, stdout: string, stderr: string): Error {
+    const output = stderr.trim() || stdout.trim();
+    if (!output) {
+      return new Error(`Prisma migrate deploy failed during startup with exit code ${exitCode ?? "unknown"}.`);
+    }
+    return new Error(`Prisma migrate deploy failed during startup with exit code ${exitCode ?? "unknown"}.\n${output}`);
+  }
+}

package/src/infrastructure/persistence/PrismaTriggerSetupStateRepository.ts

@@ -0,0 +1,68 @@
+import type { PersistedTriggerSetupState, TriggerInstanceId, TriggerSetupStateRepository } from "@codemation/core";
+import { inject, injectable } from "@codemation/core";
+import { PrismaClient } from "./generated/prisma-client/client.js";
+
+type TriggerSetupStateJson = Readonly<{
+  state: PersistedTriggerSetupState["state"];
+}>;
+
+@injectable()
+export class PrismaTriggerSetupStateRepository implements TriggerSetupStateRepository {
+  constructor(@inject(PrismaClient) private readonly prisma: PrismaClient) {}
+
+  async load(trigger: TriggerInstanceId): Promise<PersistedTriggerSetupState | undefined> {
+    const row = await this.prisma.triggerSetupState.findUnique({
+      where: {
+        workflowId_nodeId: {
+          workflowId: trigger.workflowId,
+          nodeId: trigger.nodeId,
+        },
+      },
+    });
+    if (!row) {
+      return undefined;
+    }
+    return {
+      trigger: {
+        workflowId: row.workflowId,
+        nodeId: row.nodeId,
+      },
+      updatedAt: row.updatedAt,
+      state: (JSON.parse(row.stateJson) as TriggerSetupStateJson).state,
+    };
+  }
+
+  async save(state: PersistedTriggerSetupState): Promise<void> {
+    await this.prisma.triggerSetupState.upsert({
+      where: {
+        workflowId_nodeId: {
+          workflowId: state.trigger.workflowId,
+          nodeId: state.trigger.nodeId,
+        },
+      },
+      create: {
+        workflowId: state.trigger.workflowId,
+        nodeId: state.trigger.nodeId,
+        updatedAt: state.updatedAt,
+        stateJson: JSON.stringify({
+          state: state.state,
+        } satisfies TriggerSetupStateJson),
+      },
+      update: {
+        updatedAt: state.updatedAt,
+        stateJson: JSON.stringify({
+          state: state.state,
+        } satisfies TriggerSetupStateJson),
+      },
+    });
+  }
+
+  async delete(trigger: TriggerInstanceId): Promise<void> {
+    await this.prisma.triggerSetupState.deleteMany({
+      where: {
+        workflowId: trigger.workflowId,
+        nodeId: trigger.nodeId,
+      },
+    });
+  }
+}

package/src/infrastructure/persistence/PrismaWorkflowActivationRepository.ts

@@ -0,0 +1,36 @@
+import { inject, injectable } from "@codemation/core";
+import { PrismaClient } from "./generated/prisma-client/client.js";
+import type {
+  WorkflowActivationRepository,
+  WorkflowActivationRow,
+} from "../../domain/workflows/WorkflowActivationRepository";
+
+@injectable()
+export class PrismaWorkflowActivationRepository implements WorkflowActivationRepository {
+  constructor(@inject(PrismaClient) private readonly prisma: PrismaClient) {}
+
+  async loadAll(): Promise<ReadonlyArray<WorkflowActivationRow>> {
+    const rows = await this.prisma.workflowActivation.findMany();
+    return rows.map((row) => ({
+      workflowId: row.workflowId,
+      isActive: row.isActive,
+    }));
+  }
+
+  async upsert(workflowId: string, active: boolean): Promise<void> {
+    const id = decodeURIComponent(workflowId);
+    const updatedAt = new Date().toISOString();
+    await this.prisma.workflowActivation.upsert({
+      where: { workflowId: id },
+      create: {
+        workflowId: id,
+        isActive: active,
+        updatedAt,
+      },
+      update: {
+        isActive: active,
+        updatedAt,
+      },
+    });
+  }
+}

package/src/infrastructure/persistence/PrismaWorkflowDebuggerOverlayRepository.ts

@@ -0,0 +1,65 @@
+import type { RunCurrentState } from "@codemation/core";
+import { inject, injectable } from "@codemation/core";
+import type { WorkflowDebuggerOverlayRepository } from "../../domain/workflows/WorkflowDebuggerOverlayRepository";
+import type { WorkflowDebuggerOverlayState } from "../../domain/workflows/WorkflowDebuggerOverlayState";
+import { PrismaClient } from "./generated/prisma-client/client.js";
+
+type DebuggerOverlayStateJson = Readonly<{
+  currentState: RunCurrentState;
+}>;
+
+@injectable()
+export class PrismaWorkflowDebuggerOverlayRepository implements WorkflowDebuggerOverlayRepository {
+  constructor(@inject(PrismaClient) private readonly prisma: PrismaClient) {}
+
+  async load(workflowId: string): Promise<WorkflowDebuggerOverlayState | undefined> {
+    const decodedWorkflowId = decodeURIComponent(workflowId);
+    const row = await this.prisma.workflowDebuggerOverlay.findUnique({
+      where: { workflowId: decodedWorkflowId },
+    });
+    if (!row) {
+      return undefined;
+    }
+    return this.rowToState(row);
+  }
+
+  async save(state: WorkflowDebuggerOverlayState): Promise<void> {
+    await this.prisma.workflowDebuggerOverlay.upsert({
+      where: { workflowId: state.workflowId },
+      create: {
+        workflowId: state.workflowId,
+        updatedAt: state.updatedAt,
+        copiedFromRunId: state.copiedFromRunId ?? null,
+        stateJson: JSON.stringify(this.toStateJson(state)),
+      },
+      update: {
+        updatedAt: state.updatedAt,
+        copiedFromRunId: state.copiedFromRunId ?? null,
+        stateJson: JSON.stringify(this.toStateJson(state)),
+      },
+    });
+  }
+
+  private rowToState(
+    row: Readonly<{
+      workflowId: string;
+      updatedAt: string;
+      copiedFromRunId: string | null;
+      stateJson: string;
+    }>,
+  ): WorkflowDebuggerOverlayState {
+    const parsed = JSON.parse(row.stateJson) as DebuggerOverlayStateJson;
+    return {
+      workflowId: row.workflowId,
+      updatedAt: row.updatedAt,
+      copiedFromRunId: row.copiedFromRunId ?? undefined,
+      currentState: parsed.currentState,
+    };
+  }
+
+  private toStateJson(state: WorkflowDebuggerOverlayState): DebuggerOverlayStateJson {
+    return {
+      currentState: state.currentState,
+    };
+  }
+}

package/src/infrastructure/persistence/PrismaWorkflowRunRepository.ts

@@ -0,0 +1,243 @@
+import type {
+  NodeId,
+  NodeOutputs,
+  ParentExecutionRef,
+  PersistedRunState,
+  RunId,
+  RunPruneCandidate,
+  RunSummary,
+  WorkflowExecutionRepository,
+  WorkflowId,
+} from "@codemation/core";
+import { inject, injectable } from "@codemation/core";
+import type { WorkflowRunRepository } from "../../domain/runs/WorkflowRunRepository";
+import { PrismaClient } from "./generated/prisma-client/client.js";
+
+/** JSON blob stored in stateJson: workflowSnapshot, mutableState, pending, queue, outputsByNode, nodeSnapshotsByNodeId, connectionInvocations, engineCounters */
+interface StateJsonBlob {
+  control?: PersistedRunState["control"];
+  workflowSnapshot?: PersistedRunState["workflowSnapshot"];
+  mutableState?: PersistedRunState["mutableState"];
+  policySnapshot?: PersistedRunState["policySnapshot"];
+  engineCounters?: PersistedRunState["engineCounters"];
+  pending?: PersistedRunState["pending"];
+  queue: PersistedRunState["queue"];
+  outputsByNode: Record<NodeId, NodeOutputs>;
+  nodeSnapshotsByNodeId: PersistedRunState["nodeSnapshotsByNodeId"];
+  connectionInvocations?: PersistedRunState["connectionInvocations"];
+}
+
+@injectable()
+export class PrismaWorkflowRunRepository implements WorkflowRunRepository, WorkflowExecutionRepository {
+  constructor(@inject(PrismaClient) private readonly prisma: PrismaClient) {}
+
+  async createRun(args: {
+    runId: RunId;
+    workflowId: WorkflowId;
+    startedAt: string;
+    parent?: ParentExecutionRef;
+    executionOptions?: PersistedRunState["executionOptions"];
+    control?: PersistedRunState["control"];
+    workflowSnapshot?: PersistedRunState["workflowSnapshot"];
+    mutableState?: PersistedRunState["mutableState"];
+    policySnapshot?: PersistedRunState["policySnapshot"];
+    engineCounters?: PersistedRunState["engineCounters"];
+  }): Promise<void> {
+    const now = new Date().toISOString();
+    const state: PersistedRunState = {
+      runId: args.runId,
+      workflowId: args.workflowId,
+      startedAt: args.startedAt,
+      parent: args.parent,
+      executionOptions: args.executionOptions,
+      control: args.control,
+      workflowSnapshot: args.workflowSnapshot,
+      mutableState: args.mutableState,
+      policySnapshot: args.policySnapshot,
+      engineCounters: args.engineCounters,
+      status: "running",
+      queue: [],
+      outputsByNode: {} as Record<NodeId, NodeOutputs>,
+      nodeSnapshotsByNodeId: {},
+      connectionInvocations: [],
+    };
+    const stateJson = this.serializeStateBlob(state);
+    await this.prisma.run.create({
+      data: {
+        runId: args.runId,
+        workflowId: args.workflowId,
+        startedAt: args.startedAt,
+        status: "running",
+        parentJson: args.parent ? JSON.stringify(args.parent) : null,
+        executionOptionsJson: args.executionOptions ? JSON.stringify(args.executionOptions) : null,
+        updatedAt: now,
+        stateJson,
+      },
+    });
+  }
+
+  async load(runId: string): Promise<PersistedRunState | undefined> {
+    const id = decodeURIComponent(runId) as RunId;
+    const row = await this.prisma.run.findUnique({ where: { runId: id } });
+    if (!row) return undefined;
+    return this.rowToPersistedRunState(row);
+  }
+
+  async save(state: PersistedRunState): Promise<void> {
+    const now = new Date().toISOString();
+    const stateJson = this.serializeStateBlob(state);
+    await this.prisma.run.upsert({
+      where: { runId: state.runId },
+      create: {
+        runId: state.runId,
+        workflowId: state.workflowId,
+        startedAt: state.startedAt,
+        status: state.status,
+        parentJson: state.parent ? JSON.stringify(state.parent) : null,
+        executionOptionsJson: state.executionOptions ? JSON.stringify(state.executionOptions) : null,
+        updatedAt: now,
+        stateJson,
+      },
+      update: {
+        status: state.status,
+        parentJson: state.parent ? JSON.stringify(state.parent) : null,
+        executionOptionsJson: state.executionOptions ? JSON.stringify(state.executionOptions) : null,
+        updatedAt: now,
+        stateJson,
+      },
+    });
+  }
+
+  async listRuns(args: Readonly<{ workflowId?: string; limit?: number }>): Promise<ReadonlyArray<RunSummary>> {
+    const limit = args?.limit ?? 50;
+    const workflowId = args?.workflowId ? decodeURIComponent(args.workflowId) : undefined;
+    const rows = await this.prisma.run.findMany({
+      where: workflowId ? { workflowId } : undefined,
+      orderBy: { startedAt: "desc" },
+      take: limit,
+    });
+    return rows.map((r) => this.rowToRunSummary(r));
+  }
+
+  async deleteRun(runId: RunId): Promise<void> {
+    const id = decodeURIComponent(runId);
+    await this.prisma.run.delete({ where: { runId: id } });
+  }
+
+  async listRunsOlderThan(
+    args: Readonly<{ beforeIso: string; limit?: number }>,
+  ): Promise<ReadonlyArray<RunPruneCandidate>> {
+    const limit = args.limit ?? 100;
+    const rows = await this.prisma.run.findMany({
+      where: {
+        status: { in: ["completed", "failed"] },
+        updatedAt: { lt: args.beforeIso },
+      },
+      orderBy: { updatedAt: "asc" },
+      take: limit,
+    });
+    return rows.map((r) => this.rowToPruneCandidate(r));
+  }
+
+  private serializeStateBlob(state: PersistedRunState): string {
+    const blob: StateJsonBlob = {
+      control: state.control,
+      workflowSnapshot: state.workflowSnapshot,
+      mutableState: state.mutableState,
+      policySnapshot: state.policySnapshot,
+      engineCounters: state.engineCounters,
+      pending: state.pending,
+      queue: state.queue,
+      outputsByNode: state.outputsByNode,
+      nodeSnapshotsByNodeId: state.nodeSnapshotsByNodeId,
+      connectionInvocations: state.connectionInvocations,
+    };
+    return JSON.stringify(blob);
+  }
+
+  private parseStateBlob(json: string): StateJsonBlob {
+    const parsed = JSON.parse(json) as StateJsonBlob;
+    return {
+      control: parsed.control,
+      workflowSnapshot: parsed.workflowSnapshot,
+      mutableState: parsed.mutableState,
+      policySnapshot: parsed.policySnapshot,
+      engineCounters: parsed.engineCounters,
+      pending: parsed.pending,
+      queue: parsed.queue ?? [],
+      outputsByNode: (parsed.outputsByNode ?? {}) as Record<NodeId, NodeOutputs>,
+      nodeSnapshotsByNodeId: parsed.nodeSnapshotsByNodeId ?? {},
+      connectionInvocations: parsed.connectionInvocations,
+    };
+  }
+
+  private rowToPersistedRunState(row: {
+    runId: string;
+    workflowId: string;
+    startedAt: string;
+    status: string;
+    parentJson: string | null;
+    executionOptionsJson: string | null;
+    stateJson: string;
+  }): PersistedRunState {
+    const blob = this.parseStateBlob(row.stateJson);
+    return {
+      runId: row.runId as RunId,
+      workflowId: row.workflowId as WorkflowId,
+      startedAt: row.startedAt,
+      status: row.status as PersistedRunState["status"],
+      parent: row.parentJson ? (JSON.parse(row.parentJson) as ParentExecutionRef) : undefined,
+      executionOptions: row.executionOptionsJson
+        ? (JSON.parse(row.executionOptionsJson) as PersistedRunState["executionOptions"])
+        : undefined,
+      control: blob.control,
+      workflowSnapshot: blob.workflowSnapshot,
+      mutableState: blob.mutableState,
+      policySnapshot: blob.policySnapshot,
+      engineCounters: blob.engineCounters,
+      pending: blob.pending,
+      queue: blob.queue,
+      outputsByNode: blob.outputsByNode,
+      nodeSnapshotsByNodeId: blob.nodeSnapshotsByNodeId,
+      connectionInvocations: blob.connectionInvocations,
+    };
+  }
+
+  private rowToPruneCandidate(row: {
+    runId: string;
+    workflowId: string;
+    startedAt: string;
+    updatedAt: string;
+  }): RunPruneCandidate {
+    return {
+      runId: row.runId as RunId,
+      workflowId: row.workflowId as WorkflowId,
+      startedAt: row.startedAt,
+      finishedAt: row.updatedAt,
+    };
+  }
+
+  private rowToRunSummary(row: {
+    runId: string;
+    workflowId: string;
+    startedAt: string;
+    status: string;
+    parentJson: string | null;
+    executionOptionsJson: string | null;
+    updatedAt: string;
+  }): RunSummary {
+    const status = row.status as RunSummary["status"];
+    const finishedAt = status === "completed" || status === "failed" ? row.updatedAt : undefined;
+    return {
+      runId: row.runId as RunId,
+      workflowId: row.workflowId as WorkflowId,
+      startedAt: row.startedAt,
+      status,
+      finishedAt,
+      parent: row.parentJson ? (JSON.parse(row.parentJson) as ParentExecutionRef) : undefined,
+      executionOptions: row.executionOptionsJson
+        ? (JSON.parse(row.executionOptionsJson) as RunSummary["executionOptions"])
+        : undefined,
+    };
+  }
+}

package/src/infrastructure/persistence/RuntimeWorkflowActivationPolicy.ts

@@ -0,0 +1,27 @@
+import type { WorkflowActivationPolicy, WorkflowId } from "@codemation/core";
+import { injectable } from "@codemation/core";
+import type { WorkflowActivationRepository } from "../../domain/workflows/WorkflowActivationRepository";
+
+/**
+ * In-memory activation map: missing workflow id ⇒ inactive. Hydrated from persistence at startup and updated on command.
+ */
+@injectable()
+export class RuntimeWorkflowActivationPolicy implements WorkflowActivationPolicy {
+  private readonly activeByWorkflowId = new Map<string, boolean>();
+
+  async hydrateFromRepository(repository: WorkflowActivationRepository): Promise<void> {
+    const rows = await repository.loadAll();
+    this.activeByWorkflowId.clear();
+    for (const row of rows) {
+      this.activeByWorkflowId.set(decodeURIComponent(row.workflowId), row.isActive);
+    }
+  }
+
+  set(workflowId: string, active: boolean): void {
+    this.activeByWorkflowId.set(decodeURIComponent(workflowId), active);
+  }
+
+  isActive(workflowId: WorkflowId): boolean {
+    return this.activeByWorkflowId.get(workflowId) ?? false;
+  }
+}

package/src/infrastructure/persistence/SchedulerPersistenceCompatibilityValidator.ts

@@ -0,0 +1,20 @@
+import type { ResolvedDatabasePersistence } from "./DatabasePersistenceResolver";
+import type { CodemationSchedulerKind } from "../../presentation/config/CodemationConfig";
+
+/**
+ * Ensures scheduler and database selections are compatible (e.g. BullMQ requires shared TCP PostgreSQL).
+ */
+export class SchedulerPersistenceCompatibilityValidator {
+  validate(args: Readonly<{ schedulerKind: CodemationSchedulerKind; persistence: ResolvedDatabasePersistence }>): void {
+    if (args.schedulerKind === "bullmq" && args.persistence.kind === "none") {
+      throw new Error(
+        "BullMQ requires PostgreSQL persistence. Configure runtime.database with a postgresql URL (embedded PGlite is not compatible with BullMQ).",
+      );
+    }
+    if (args.schedulerKind === "bullmq" && args.persistence.kind === "pglite") {
+      throw new Error(
+        'BullMQ requires a shared PostgreSQL database. PGlite cannot be used with the BullMQ scheduler. Set runtime.database.kind to "postgresql" with a PostgreSQL URL, or use the local scheduler when using PGlite.',
+      );
+    }
+  }
+}

package/src/infrastructure/persistence/WorkflowDefinitionRepositoryAdapter.ts

@@ -0,0 +1,31 @@
+import type { WorkflowDefinition, WorkflowExecutionRepository, WorkflowRepository } from "@codemation/core";
+import { CoreTokens, inject, injectable } from "@codemation/core";
+import { Engine } from "@codemation/core/bootstrap";
+import { WorkflowDefinitionRepository } from "../../domain/workflows/WorkflowDefinitionRepository";
+
+@injectable()
+export class WorkflowDefinitionRepositoryAdapter implements WorkflowDefinitionRepository {
+  constructor(
+    @inject(Engine) private readonly engine: Engine,
+    @inject(CoreTokens.WorkflowRepository) private readonly workflowRepository: WorkflowRepository,
+  ) {}
+
+  async listDefinitions(): Promise<ReadonlyArray<WorkflowDefinition>> {
+    return [...this.workflowRepository.list()];
+  }
+
+  async getDefinition(workflowId: string): Promise<WorkflowDefinition | undefined> {
+    return this.workflowRepository.get(decodeURIComponent(workflowId));
+  }
+
+  async resolveSnapshot(
+    args: Readonly<{ workflowId: string; workflowSnapshot?: unknown }>,
+  ): Promise<WorkflowDefinition | undefined> {
+    return this.engine.resolveWorkflowSnapshot({
+      workflowId: decodeURIComponent(args.workflowId),
+      workflowSnapshot: args.workflowSnapshot as NonNullable<
+        Awaited<ReturnType<WorkflowExecutionRepository["load"]>>
+      >["workflowSnapshot"],
+    });
+  }
+}