@codemation/host 0.6.0 → 0.8.0

package/src/infrastructure/config/CodemationPluginRegistrar.ts

@@ -1,4 +1,4 @@
-import type { AnyCredentialType, CollectionDefinition, Container } from "@codemation/core";
+import type { AnyCredentialType, CollectionDefinition, Container, McpServerDeclaration } from "@codemation/core";
 import type { LoggerFactory } from "../../application/logging/Logger";
 import type { AppConfig } from "../../presentation/config/AppConfig";
 import type { CodemationPlugin } from "../../presentation/config/CodemationPlugin";
@@ -11,6 +11,7 @@ export class CodemationPluginRegistrar {
       appConfig: AppConfig;
       registerCredentialType: (type: AnyCredentialType) => void;
       registerCollection: (definition: CollectionDefinition) => void;
+      mergeMcpServers: (declarations: ReadonlyArray<McpServerDeclaration>) => void;
       loggerFactory: LoggerFactory;
     }>,
   ): Promise<void> {
@@ -18,6 +19,7 @@ export class CodemationPluginRegistrar {
       for (const credentialType of plugin.credentialTypes ?? []) {
         args.registerCredentialType(credentialType);
       }
+      args.mergeMcpServers(plugin.mcpServers ?? []);
       if (!plugin.register) {
         continue;
       }

package/src/infrastructure/persistence/CodemationDatabaseUrlParser.ts

@@ -0,0 +1,41 @@
+import path from "node:path";
+import type { AppPersistenceConfig } from "../../presentation/config/AppConfig";
+
+/**
+ * Parses `CODEMATION_DATABASE_URL` into an {@link AppPersistenceConfig}.
+ *
+ * Supported schemes (case-insensitive):
+ *   - `sqlite://relative/path/to/file.db`    → resolved relative to consumerRoot
+ *   - `sqlite:///absolute/path/to/file.db`   → leading slash = POSIX absolute
+ *   - `sqlite://C:/path/file.db`             → Windows-style absolute (path.isAbsolute()
+ *                                              returns true for these)
+ *   - `pgsql://user:pass@host:5432/dbname`   → normalised to postgresql://
+ *   - `postgresql://user:pass@host:5432/db`  → pass-through (Prisma's expected scheme)
+ *   - `postgres://user:pass@host:5432/db`    → pass-through (common alias)
+ *
+ * Throws on any other scheme. Empty / whitespace input is also an error — callers
+ * should default before calling parse().
+ */
+export class CodemationDatabaseUrlParser {
+  parse(url: string, consumerRoot: string): AppPersistenceConfig {
+    const trimmed = url.trim();
+    if (trimmed.length === 0) {
+      throw new Error("CODEMATION_DATABASE_URL is empty.");
+    }
+    if (trimmed.toLowerCase().startsWith("sqlite://")) {
+      const remainder = trimmed.slice("sqlite://".length);
+      const filePath = path.isAbsolute(remainder) ? remainder : path.resolve(consumerRoot, remainder);
+      return { kind: "sqlite", databaseFilePath: filePath };
+    }
+    if (trimmed.toLowerCase().startsWith("pgsql://")) {
+      return { kind: "postgresql", databaseUrl: `postgresql://${trimmed.slice("pgsql://".length)}` };
+    }
+    if (trimmed.toLowerCase().startsWith("postgresql://") || trimmed.toLowerCase().startsWith("postgres://")) {
+      return { kind: "postgresql", databaseUrl: trimmed };
+    }
+    throw new Error(
+      `Unsupported CODEMATION_DATABASE_URL scheme: "${trimmed}". ` +
+        `Use sqlite://, pgsql://, postgresql://, or postgres://.`,
+    );
+  }
+}

package/src/infrastructure/persistence/InMemoryTelemetryArtifactStore.ts

@@ -4,6 +4,7 @@ import type {
   TelemetryArtifactRecord,
   TelemetryArtifactStore,
   TelemetryArtifactWrite,
+  TelemetryPruneArgs,
 } from "../../domain/telemetry/TelemetryContracts";
 
 @injectable()
@@ -43,14 +44,18 @@ export class InMemoryTelemetryArtifactStore implements TelemetryArtifactStore {
       .sort((left, right) => left.createdAt.localeCompare(right.createdAt));
   }
 
-  async pruneExpired(args: Readonly<{ nowIso: string; limit?: number }>): Promise<number> {
+  async pruneExpired(args: TelemetryPruneArgs): Promise<{ count: number; storageKeys: ReadonlyArray<string> }> {
     const candidates = [...this.rows.entries()]
       .filter(([, row]) => row.retentionExpiresAt !== undefined && row.retentionExpiresAt <= args.nowIso)
       .sort((left, right) => (left[1].retentionExpiresAt ?? "").localeCompare(right[1].retentionExpiresAt ?? ""))
       .slice(0, args.limit ?? Number.MAX_SAFE_INTEGER);
-    for (const [key] of candidates) {
+    const storageKeys: string[] = [];
+    for (const [key, row] of candidates) {
+      if (row.payloadStorageKey) {
+        storageKeys.push(row.payloadStorageKey);
+      }
       this.rows.delete(key);
     }
-    return candidates.length;
+    return { count: candidates.length, storageKeys };
   }
 }

package/src/infrastructure/persistence/PrismaMigrationDeployer.ts

@@ -1,4 +1,4 @@
-import { createClient, type Client } from "@libsql/client";
+import type { Client } from "@libsql/client";
 import { injectable } from "@codemation/core";
 import { spawn } from "node:child_process";
 import { existsSync } from "node:fs";
@@ -105,11 +105,12 @@ export class PrismaMigrationDeployer {
       env?: Readonly<NodeJS.ProcessEnv>;
     }>,
   ): Promise<void> {
-    const prismaConfigPath = this.resolveAbsolutePrismaConfigPath();
+    const resolverEnv = { ...process.env, ...(args.env ?? {}) };
+    const prismaConfigPath = this.resolveAbsolutePrismaConfigPath(resolverEnv);
     await new Promise<void>((resolve, reject) => {
       const command = spawn(
         process.execPath,
-        [...[this.resolvePrismaCliPath(), ...args.prismaArgs], "--config", path.basename(prismaConfigPath)],
+        [...[this.resolvePrismaCliPath(resolverEnv), ...args.prismaArgs], "--config", path.basename(prismaConfigPath)],
         {
           cwd: path.dirname(prismaConfigPath),
           env: this.createProcessEnvironment(args.databaseUrl, args.provider, args.env),
@@ -177,6 +178,10 @@ export class PrismaMigrationDeployer {
   }
 
   private async repairPartiallyAppliedNormalizedRuntimeSqliteDatabase(databaseFilePath: string): Promise<boolean> {
+    // Lazy import: @libsql/client pulls in platform-specific native bindings that confuse the
+    // Next.js / Turbopack module tracer (forcing the whole project to be traced via NFT). This
+    // recovery path is rarely needed, so defer the load until it's actually invoked.
+    const { createClient } = await import("@libsql/client");
     const client = createClient({ url: this.sqliteFilePathToDatabaseUrl(databaseFilePath) });
     try {
       const failedMigration = await this.hasActiveFailedMigrationRecord(
@@ -288,6 +293,7 @@ export class PrismaMigrationDeployer {
   }
 
   private async cleanupNormalizedRuntimeLegacyArtifacts(databaseFilePath: string): Promise<void> {
+    const { createClient } = await import("@libsql/client");
     const client = createClient({ url: this.sqliteFilePathToDatabaseUrl(databaseFilePath) });
     try {
       const runColumns = await this.readSqliteTableColumns(client, "Run");
@@ -326,14 +332,15 @@ export class PrismaMigrationDeployer {
     };
   }
 
-  private resolvePrismaCliPath(): string {
-    const configuredPath = process.env.CODEMATION_PRISMA_CLI_PATH;
+  private resolvePrismaCliPath(env: Readonly<NodeJS.ProcessEnv>): string {
+    const configuredPath = env.CODEMATION_PRISMA_CLI_PATH;
     if (configuredPath && existsSync(configuredPath)) {
       return configuredPath;
     }
+    const packageRoot = this.resolvePackageRoot(env);
     const packageManagerCandidates = [
       path.resolve(process.cwd(), "node_modules", "prisma", "build", "index.js"),
-      path.resolve(this.resolvePackageRoot(), "node_modules", "prisma", "build", "index.js"),
+      path.resolve(packageRoot, "node_modules", "prisma", "build", "index.js"),
     ];
     for (const candidate of packageManagerCandidates) {
       if (existsSync(candidate)) {
@@ -342,7 +349,7 @@ export class PrismaMigrationDeployer {
     }
     try {
       return this.require.resolve("prisma/build/index.js", {
-        paths: [process.cwd(), this.resolvePackageRoot()],
+        paths: [process.cwd(), packageRoot],
       });
     } catch {
       throw new Error(
@@ -351,16 +358,17 @@ export class PrismaMigrationDeployer {
     }
   }
 
-  private resolveAbsolutePrismaConfigPath(): string {
-    const configuredPath = process.env.CODEMATION_PRISMA_CONFIG_PATH;
+  private resolveAbsolutePrismaConfigPath(env: Readonly<NodeJS.ProcessEnv>): string {
+    const configuredPath = env.CODEMATION_PRISMA_CONFIG_PATH;
+    const packageRoot = this.resolvePackageRoot(env);
     if (configuredPath) {
-      return path.isAbsolute(configuredPath) ? configuredPath : path.resolve(this.resolvePackageRoot(), configuredPath);
+      return path.isAbsolute(configuredPath) ? configuredPath : path.resolve(packageRoot, configuredPath);
     }
-    return path.resolve(this.resolvePackageRoot(), "prisma.config.ts");
+    return path.resolve(packageRoot, "prisma.config.ts");
   }
 
-  resolvePackageRoot(): string {
-    const configuredRoot = process.env.CODEMATION_HOST_PACKAGE_ROOT;
+  resolvePackageRoot(env: Readonly<NodeJS.ProcessEnv> = process.env): string {
+    const configuredRoot = env.CODEMATION_HOST_PACKAGE_ROOT;
     if (configuredRoot) {
       return configuredRoot;
     }

package/src/infrastructure/persistence/PrismaTelemetryArtifactStore.ts

@@ -1,12 +1,17 @@
-import { inject, injectable } from "@codemation/core";
+import type { BinaryBody, BinaryStorage } from "@codemation/core";
+import { CoreTokens, inject, injectable } from "@codemation/core";
 import { OtelIdentityFactory } from "../../application/telemetry/OtelIdentityFactory";
 import type {
   TelemetryArtifactRecord,
   TelemetryArtifactStore,
   TelemetryArtifactWrite,
+  TelemetryPruneArgs,
 } from "../../domain/telemetry/TelemetryContracts";
 import { PrismaDatabaseClientToken, type PrismaDatabaseClient } from "./PrismaDatabaseClient";
 
+/** Payloads larger than this byte threshold are offloaded to BinaryStorage. */
+const PAYLOAD_OFFLOAD_THRESHOLD_BYTES = 64_000;
+
 @injectable()
 export class PrismaTelemetryArtifactStore implements TelemetryArtifactStore {
   constructor(
@@ -14,11 +19,36 @@ export class PrismaTelemetryArtifactStore implements TelemetryArtifactStore {
     private readonly prisma: PrismaDatabaseClient,
     @inject(OtelIdentityFactory)
     private readonly otelIdentityFactory: OtelIdentityFactory,
+    @inject(CoreTokens.BinaryStorage)
+    private readonly binaryStorage: BinaryStorage,
   ) {}
 
   async save(record: TelemetryArtifactWrite): Promise<TelemetryArtifactRecord> {
     const artifactId = this.otelIdentityFactory.createArtifactId();
     const createdAt = new Date().toISOString();
+
+    // Resolve inline vs offloaded payload
+    let payloadText: string | null = record.payloadText ?? null;
+    let payloadJson: string | null = record.payloadJson !== undefined ? JSON.stringify(record.payloadJson) : null;
+    let payloadStorageKey: string | null = null;
+
+    const payloadTextBytes = payloadText ? Buffer.byteLength(payloadText, "utf8") : 0;
+    const payloadJsonBytes = payloadJson ? Buffer.byteLength(payloadJson, "utf8") : 0;
+
+    if (payloadTextBytes > PAYLOAD_OFFLOAD_THRESHOLD_BYTES) {
+      const storageKey = `telemetry-artifacts/${artifactId}.txt`;
+      const body: BinaryBody = Buffer.from(payloadText!, "utf8");
+      await this.binaryStorage.write({ storageKey, body });
+      payloadStorageKey = storageKey;
+      payloadText = null;
+    } else if (payloadJsonBytes > PAYLOAD_OFFLOAD_THRESHOLD_BYTES) {
+      const storageKey = `telemetry-artifacts/${artifactId}.json`;
+      const body: BinaryBody = Buffer.from(payloadJson!, "utf8");
+      await this.binaryStorage.write({ storageKey, body });
+      payloadStorageKey = storageKey;
+      payloadJson = null;
+    }
+
     await this.prisma.telemetryArtifact.create({
       data: {
         artifactId,
@@ -32,8 +62,9 @@ export class PrismaTelemetryArtifactStore implements TelemetryArtifactStore {
         contentType: record.contentType,
         previewText: record.previewText ?? null,
         previewJson: record.previewJson !== undefined ? JSON.stringify(record.previewJson) : null,
-        payloadText: record.payloadText ?? null,
-        payloadJson: record.payloadJson !== undefined ? JSON.stringify(record.payloadJson) : null,
+        payloadText,
+        payloadJson,
+        payloadStorageKey,
         bytes: record.bytes ?? null,
         truncated: record.truncated ?? null,
         createdAt,
@@ -53,8 +84,9 @@ export class PrismaTelemetryArtifactStore implements TelemetryArtifactStore {
       contentType: record.contentType,
       previewText: record.previewText,
       previewJson: record.previewJson,
-      payloadText: record.payloadText,
-      payloadJson: record.payloadJson,
+      payloadText: payloadText ?? undefined,
+      payloadJson: payloadJson !== null ? JSON.parse(payloadJson) : undefined,
+      payloadStorageKey: payloadStorageKey ?? undefined,
       bytes: record.bytes,
       truncated: record.truncated,
       createdAt,
@@ -82,6 +114,7 @@ export class PrismaTelemetryArtifactStore implements TelemetryArtifactStore {
       previewJson: this.parseJson(row.previewJson),
       payloadText: row.payloadText ?? undefined,
       payloadJson: this.parseJson(row.payloadJson),
+      payloadStorageKey: row.payloadStorageKey ?? undefined,
       bytes: row.bytes ?? undefined,
       truncated: row.truncated ?? undefined,
       createdAt: row.createdAt,
@@ -90,7 +123,7 @@ export class PrismaTelemetryArtifactStore implements TelemetryArtifactStore {
     }));
   }
 
-  async pruneExpired(args: Readonly<{ nowIso: string; limit?: number }>): Promise<number> {
+  async pruneExpired(args: TelemetryPruneArgs): Promise<{ count: number; storageKeys: ReadonlyArray<string> }> {
     const rows = await this.prisma.telemetryArtifact.findMany({
       where: {
         retentionExpiresAt: {
@@ -99,13 +132,15 @@ export class PrismaTelemetryArtifactStore implements TelemetryArtifactStore {
       },
       select: {
         artifactId: true,
+        payloadStorageKey: true,
       },
       orderBy: [{ retentionExpiresAt: "asc" }, { artifactId: "asc" }],
       ...(args.limit ? { take: args.limit } : {}),
     });
     if (rows.length === 0) {
-      return 0;
+      return { count: 0, storageKeys: [] };
     }
+    const storageKeys = rows.flatMap((row) => (row.payloadStorageKey ? [row.payloadStorageKey] : []));
     const result = await this.prisma.telemetryArtifact.deleteMany({
       where: {
         artifactId: {
@@ -113,7 +148,7 @@ export class PrismaTelemetryArtifactStore implements TelemetryArtifactStore {
         },
       },
     });
-    return result.count;
+    return { count: result.count, storageKeys };
   }
 
   private parseJson(value: string | null): unknown {

package/src/infrastructure/persistence/PrismaWorkflowRunRepository.ts

@@ -22,6 +22,8 @@ import { inject, injectable } from "@codemation/core";
 import type { WorkflowRunRepository } from "../../domain/runs/WorkflowRunRepository";
 import type { Prisma } from "../../../prisma-generated/prisma-postgresql-client/client.js";
 import { PrismaDatabaseClientToken, type PrismaDatabaseClient } from "./PrismaDatabaseClient";
+import type { WorkflowSnapshotRepository } from "./PrismaWorkflowSnapshotRepository";
+import { PrismaWorkflowSnapshotRepository } from "./PrismaWorkflowSnapshotRepository";
 
 type ExecutionInstanceRow = {
   instanceId: string;
@@ -80,7 +82,10 @@ type RunSlotProjectionRow = {
 
 @injectable()
 export class PrismaWorkflowRunRepository implements WorkflowRunRepository, WorkflowExecutionRepository {
-  constructor(@inject(PrismaDatabaseClientToken) private readonly prisma: PrismaDatabaseClient) {}
+  constructor(
+    @inject(PrismaDatabaseClientToken) private readonly prisma: PrismaDatabaseClient,
+    @inject(PrismaWorkflowSnapshotRepository) private readonly snapshotRepo: WorkflowSnapshotRepository,
+  ) {}
 
   async createRun(args: {
     runId: RunId;
@@ -96,6 +101,14 @@ export class PrismaWorkflowRunRepository implements WorkflowRunRepository, Workf
   }): Promise<void> {
     const now = new Date().toISOString();
     const testContext = args.executionOptions?.testContext;
+    const snapshotJson = args.workflowSnapshot ? JSON.stringify(args.workflowSnapshot) : null;
+    const workflowSnapshotId =
+      snapshotJson !== null
+        ? await this.snapshotRepo.findOrCreate({
+            workflowId: args.workflowId,
+            snapshotJson,
+          })
+        : null;
     await this.prisma.run.create({
       data: {
         runId: args.runId,
@@ -108,7 +121,8 @@ export class PrismaWorkflowRunRepository implements WorkflowRunRepository, Workf
         revision: 0,
         outputsByNodeJson: JSON.stringify({}),
         controlJson: args.control ? JSON.stringify(args.control) : null,
-        workflowSnapshotJson: args.workflowSnapshot ? JSON.stringify(args.workflowSnapshot) : null,
+        workflowSnapshotJson: snapshotJson,
+        workflowSnapshotId,
         policySnapshotJson: args.policySnapshot ? JSON.stringify(args.policySnapshot) : null,
         engineCountersJson: args.engineCounters ? JSON.stringify(args.engineCounters) : null,
         mutableStateJson: args.mutableState ? JSON.stringify(args.mutableState) : null,
@@ -290,6 +304,14 @@ export class PrismaWorkflowRunRepository implements WorkflowRunRepository, Workf
     const workItems = this.buildWorkItems(state, now);
     const instances = this.buildExecutionInstances(state);
     const projectionJson = this.buildProjectionSlotStatesJson(state);
+    const snapshotJson = state.workflowSnapshot ? JSON.stringify(state.workflowSnapshot) : null;
+    const workflowSnapshotId =
+      snapshotJson !== null
+        ? await this.snapshotRepo.findOrCreate({
+            workflowId: state.workflowId,
+            snapshotJson,
+          })
+        : null;
 
     await this.prisma.$transaction(async (tx) => {
       await tx.runWorkItem.deleteMany({ where: { runId: state.runId } });
@@ -389,7 +411,8 @@ export class PrismaWorkflowRunRepository implements WorkflowRunRepository, Workf
           parentJson: state.parent ? JSON.stringify(state.parent) : null,
           executionOptionsJson: state.executionOptions ? JSON.stringify(state.executionOptions) : null,
           controlJson: state.control ? JSON.stringify(state.control) : null,
-          workflowSnapshotJson: state.workflowSnapshot ? JSON.stringify(state.workflowSnapshot) : null,
+          workflowSnapshotJson: snapshotJson,
+          workflowSnapshotId,
           policySnapshotJson: state.policySnapshot ? JSON.stringify(state.policySnapshot) : null,
           engineCountersJson: state.engineCounters ? JSON.stringify(state.engineCounters) : null,
           mutableStateJson: state.mutableState ? JSON.stringify(state.mutableState) : null,

package/src/infrastructure/persistence/PrismaWorkflowSnapshotRepository.ts

@@ -0,0 +1,48 @@
+import { createHash } from "node:crypto";
+import { inject, injectable } from "@codemation/core";
+import { PrismaDatabaseClientToken, type PrismaDatabaseClient } from "./PrismaDatabaseClient";
+
+export interface WorkflowSnapshotRepository {
+  /**
+   * Returns the id of an existing snapshot matching (workflowId, snapshotHash), or creates
+   * a new one from the provided snapshotJson. Deduplication is by content hash.
+   */
+  findOrCreate(args: Readonly<{ workflowId: string; snapshotJson: string }>): Promise<string>;
+}
+
+@injectable()
+export class PrismaWorkflowSnapshotRepository implements WorkflowSnapshotRepository {
+  constructor(
+    @inject(PrismaDatabaseClientToken)
+    private readonly prisma: PrismaDatabaseClient,
+  ) {}
+
+  async findOrCreate(args: Readonly<{ workflowId: string; snapshotJson: string }>): Promise<string> {
+    const snapshotHash = createHash("sha256").update(args.snapshotJson, "utf8").digest("hex");
+    const existing = await this.prisma.workflowSnapshot.findUnique({
+      where: { workflowId_snapshotHash: { workflowId: args.workflowId, snapshotHash } },
+      select: { id: true },
+    });
+    if (existing) {
+      return existing.id;
+    }
+    const id = crypto.randomUUID();
+    await this.prisma.workflowSnapshot.upsert({
+      where: { workflowId_snapshotHash: { workflowId: args.workflowId, snapshotHash } },
+      create: {
+        id,
+        workflowId: args.workflowId,
+        snapshotHash,
+        snapshotJson: args.snapshotJson,
+        createdAt: new Date().toISOString(),
+      },
+      update: {},
+    });
+    // Re-fetch so the returned id is the winner under concurrent inserts
+    const row = await this.prisma.workflowSnapshot.findUniqueOrThrow({
+      where: { workflowId_snapshotHash: { workflowId: args.workflowId, snapshotHash } },
+      select: { id: true },
+    });
+    return row.id;
+  }
+}