@codemation/cli 0.0.1

package/dist/index.js

@@ -0,0 +1,4 @@
+import { a as CliProgram, i as CliPathResolver, n as CliProgramFactory, o as ConsumerOutputBuilder, r as CodemationCliApplicationSession, s as ConsumerBuildOptionsParser, t as CliBin } from "./CliBin-vjSSUDWE.js";
+import { CodemationPluginDiscovery } from "@codemation/host/server";
+
+export { CliBin, CliPathResolver, CliProgram, CliProgramFactory, CodemationCliApplicationSession, CodemationPluginDiscovery, ConsumerBuildOptionsParser, ConsumerOutputBuilder };

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@codemation/cli",
+  "version": "0.0.1",
+  "publishConfig": {
+    "access": "public"
+  },
+  "author": "Made Relevant B.V.",
+  "homepage": "https://www.maderelevant.com",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "codemation": "./bin/codemation.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "bcryptjs": "^3.0.3",
+    "boxen": "^8.0.1",
+    "chalk": "^5.6.2",
+    "chokidar": "^5.0.0",
+    "commander": "^14.0.3",
+    "dotenv": "^17.3.1",
+    "figlet": "^1.11.0",
+    "reflect-metadata": "^0.2.2",
+    "typescript": "^5.9.3",
+    "@codemation/host": "0.0.1",
+    "@codemation/dev-gateway": "0.0.1",
+    "@codemation/next-host": "0.0.1",
+    "@codemation/runtime-dev": "0.0.1",
+    "@codemation/worker-cli": "0.0.1"
+  },
+  "devDependencies": {
+    "@types/node": "^25.3.5",
+    "eslint": "^10.0.3",
+    "tsdown": "^0.15.5",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "vitest": "4.0.18",
+    "@codemation/eslint-config": "0.0.0"
+  },
+  "peerDependencies": {
+    "tsx": ">=4.0.0"
+  },
+  "scripts": {
+    "dev": "tsdown src/index.ts src/bin.ts --out-dir dist --watch",
+    "build": "tsdown src/index.ts src/bin.ts --out-dir dist",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "lint": "eslint .",
+    "test": "vitest run"
+  }
+}

package/src/CliBin.ts

@@ -0,0 +1,17 @@
+import process from "node:process";
+
+import { CliProgramFactory } from "./CliProgramFactory";
+
+export class CliBin {
+  static async run(argv: ReadonlyArray<string>): Promise<void> {
+    try {
+      const cli = new CliProgramFactory().create();
+      await cli.run([...argv]);
+    } catch (error) {
+      // Always print to stderr: host ServerLogger respects CODEMATION_LOG_LEVEL=silent and would
+      // suppress logger.error here; Prisma/DB errors also need the full Error (message + stack).
+      console.error("codemation:", error);
+      process.exitCode = 1;
+    }
+  }
+}

package/src/CliProgramFactory.ts

@@ -0,0 +1,118 @@
+import { CodemationConsumerConfigLoader, CodemationPluginDiscovery } from "@codemation/host/server";
+import { logLevelPolicyFactory, ServerLoggerFactory } from "@codemation/host/next/server";
+
+import { ConsumerBuildArtifactsPublisher } from "./build/ConsumerBuildArtifactsPublisher";
+import { ConsumerBuildOptionsParser } from "./build/ConsumerBuildOptionsParser";
+import { BuildCommand } from "./commands/BuildCommand";
+import { DbMigrateCommand } from "./commands/DbMigrateCommand";
+import { DevCommand } from "./commands/DevCommand";
+import { ServeWebCommand } from "./commands/ServeWebCommand";
+import { ServeWorkerCommand } from "./commands/ServeWorkerCommand";
+import { UserCreateCommand } from "./commands/UserCreateCommand";
+import { UserListCommand } from "./commands/UserListCommand";
+import { ConsumerCliTsconfigPreparation } from "./consumer/ConsumerCliTsconfigPreparation";
+import { ConsumerEnvLoader } from "./consumer/ConsumerEnvLoader";
+import { ConsumerOutputBuilderLoader } from "./consumer/Loader";
+import { ConsumerDatabaseConnectionResolver } from "./database/ConsumerDatabaseConnectionResolver";
+import { DatabaseMigrationsApplyService } from "./database/DatabaseMigrationsApplyService";
+import { HostPackageRootResolver } from "./database/HostPackageRootResolver";
+import { DatabasePersistenceResolver, PrismaMigrationDeployer } from "@codemation/host/persistence";
+import { DevBootstrapSummaryFetcher } from "./dev/DevBootstrapSummaryFetcher";
+import { DevCliBannerRenderer } from "./dev/DevCliBannerRenderer";
+import { DevConsumerPublishBootstrap } from "./dev/DevConsumerPublishBootstrap";
+import { DevSessionServicesBuilder } from "./dev/Builder";
+import { DevLockFactory } from "./dev/Factory";
+import { ConsumerEnvDotenvFilePredicate } from "./dev/ConsumerEnvDotenvFilePredicate";
+import { DevTrackedProcessTreeKiller } from "./dev/DevTrackedProcessTreeKiller";
+import { DevSourceWatcherFactory } from "./dev/Runner";
+import { CliProgram } from "./Program";
+import { CliPathResolver } from "./path/CliPathResolver";
+import { ListenPortResolver } from "./runtime/ListenPortResolver";
+import { SourceMapNodeOptions } from "./runtime/SourceMapNodeOptions";
+import { TypeScriptRuntimeConfigurator } from "./runtime/TypeScriptRuntimeConfigurator";
+import { LocalUserCreator } from "./user/LocalUserCreator";
+import { CliDatabaseUrlDescriptor } from "./user/CliDatabaseUrlDescriptor";
+import { UserAdminCliBootstrap } from "./user/UserAdminCliBootstrap";
+import { UserAdminCliOptionsParser } from "./user/UserAdminCliOptionsParser";
+import { UserAdminConsumerDotenvLoader } from "./user/UserAdminConsumerDotenvLoader";
+
+const loggerFactory = new ServerLoggerFactory(logLevelPolicyFactory);
+
+/**
+ * Single composition root for the CLI: constructs the object graph and returns {@link CliProgram}.
+ * No tsyringe; keeps the package thin while commands remain constructor-injected.
+ */
+export class CliProgramFactory {
+  create(): CliProgram {
+    const cliLogger = loggerFactory.create("codemation-cli");
+    const pathResolver = new CliPathResolver();
+    const pluginDiscovery = new CodemationPluginDiscovery();
+    const artifactsPublisher = new ConsumerBuildArtifactsPublisher();
+    const tsRuntime = new TypeScriptRuntimeConfigurator();
+    const outputBuilderLoader = new ConsumerOutputBuilderLoader();
+    const sourceMapNodeOptions = new SourceMapNodeOptions();
+    const tsconfigPreparation = new ConsumerCliTsconfigPreparation();
+    const databasePersistenceResolver = new DatabasePersistenceResolver();
+    const userAdminBootstrap = new UserAdminCliBootstrap(
+      new CodemationConsumerConfigLoader(),
+      pathResolver,
+      new UserAdminConsumerDotenvLoader(),
+      tsconfigPreparation,
+      databasePersistenceResolver,
+    );
+    const hostPackageRoot = new HostPackageRootResolver().resolveHostPackageRoot();
+    const userAdminCliOptionsParser = new UserAdminCliOptionsParser();
+    const databaseMigrationsApplyService = new DatabaseMigrationsApplyService(
+      cliLogger,
+      new UserAdminConsumerDotenvLoader(),
+      tsconfigPreparation,
+      new CodemationConsumerConfigLoader(),
+      new ConsumerDatabaseConnectionResolver(),
+      new CliDatabaseUrlDescriptor(),
+      hostPackageRoot,
+      new PrismaMigrationDeployer(),
+    );
+
+    const buildOptionsParser = new ConsumerBuildOptionsParser();
+    const devConsumerPublishBootstrap = new DevConsumerPublishBootstrap(
+      cliLogger,
+      pluginDiscovery,
+      artifactsPublisher,
+      outputBuilderLoader,
+      buildOptionsParser,
+    );
+    return new CliProgram(
+      buildOptionsParser,
+      new BuildCommand(cliLogger, pathResolver, pluginDiscovery, artifactsPublisher, tsRuntime, outputBuilderLoader),
+      new DevCommand(
+        pathResolver,
+        pluginDiscovery,
+        tsRuntime,
+        new DevLockFactory(),
+        new DevSourceWatcherFactory(),
+        cliLogger,
+        new DevSessionServicesBuilder(loggerFactory).build(),
+        databaseMigrationsApplyService,
+        new DevBootstrapSummaryFetcher(),
+        new DevCliBannerRenderer(),
+        devConsumerPublishBootstrap,
+        new ConsumerEnvDotenvFilePredicate(),
+        new DevTrackedProcessTreeKiller(),
+      ),
+      new ServeWebCommand(
+        pathResolver,
+        pluginDiscovery,
+        artifactsPublisher,
+        tsRuntime,
+        sourceMapNodeOptions,
+        outputBuilderLoader,
+        new ConsumerEnvLoader(),
+        new ListenPortResolver(),
+      ),
+      new ServeWorkerCommand(sourceMapNodeOptions),
+      new DbMigrateCommand(databaseMigrationsApplyService),
+      new UserCreateCommand(new LocalUserCreator(userAdminBootstrap), userAdminCliOptionsParser),
+      new UserListCommand(cliLogger, userAdminBootstrap, new CliDatabaseUrlDescriptor(), userAdminCliOptionsParser),
+    );
+  }
+}

package/src/Program.ts

@@ -0,0 +1,157 @@
+import { Command } from "commander";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+
+import { ConsumerBuildOptionsParser } from "./build/ConsumerBuildOptionsParser";
+import { BuildCommand } from "./commands/BuildCommand";
+import type { DbMigrateCommand } from "./commands/DbMigrateCommand";
+import { DevCommand } from "./commands/DevCommand";
+import { ServeWebCommand } from "./commands/ServeWebCommand";
+import { ServeWorkerCommand } from "./commands/ServeWorkerCommand";
+import { UserCreateCommand } from "./commands/UserCreateCommand";
+import { UserListCommand } from "./commands/UserListCommand";
+
+export class CliProgram {
+  constructor(
+    private readonly buildOptionsParser: ConsumerBuildOptionsParser,
+    private readonly buildCommand: BuildCommand,
+    private readonly devCommand: DevCommand,
+    private readonly serveWebCommand: ServeWebCommand,
+    private readonly serveWorkerCommand: ServeWorkerCommand,
+    private readonly dbMigrateCommand: DbMigrateCommand,
+    private readonly userCreateCommand: UserCreateCommand,
+    private readonly userListCommand: UserListCommand,
+  ) {}
+
+  async run(argv: ReadonlyArray<string>): Promise<void> {
+    const program = new Command();
+    program
+      .name("codemation")
+      .description("Build and run the Codemation Next host against a consumer project.")
+      .version(this.readCliPackageVersion(), "-V, --version", "Output CLI version")
+      .showHelpAfterError("(add --help for usage)")
+      .configureHelp({ sortSubcommands: true });
+
+    const resolveConsumerRoot = (raw: string | undefined): string =>
+      raw !== undefined && raw.trim().length > 0 ? path.resolve(process.cwd(), raw.trim()) : process.cwd();
+
+    program
+      .command("build")
+      .description("Build consumer workflows/plugins output and write the manifest.")
+      .option("--consumer-root <path>", "Path to the consumer project root (defaults to cwd)")
+      .option(
+        "--no-source-maps",
+        "Disable .js.map files for emitted workflow modules (recommended for locked-down production bundles).",
+      )
+      .option(
+        "--target <es2020|es2022>",
+        "ECMAScript language version for emitted workflow JavaScript (default: es2022).",
+        "es2022",
+      )
+      .action(async (opts: Readonly<{ consumerRoot?: string; noSourceMaps?: boolean; target?: string }>) => {
+        await this.buildCommand.execute(resolveConsumerRoot(opts.consumerRoot), this.buildOptionsParser.parse(opts));
+      });
+
+    program
+      .command("dev", { isDefault: true })
+      .description(
+        "Start the dev gateway and runtime child. Use CODEMATION_DEV_MODE=framework with Next dev for framework UI HMR; default consumer mode serves API/WebSocket from the gateway only.",
+      )
+      .option("--consumer-root <path>", "Path to the consumer project root (defaults to cwd)")
+      .action(async (opts: Readonly<{ consumerRoot?: string }>) => {
+        await this.devCommand.execute(resolveConsumerRoot(opts.consumerRoot));
+      });
+
+    const serve = program.command("serve").description("Run production web or worker processes (no dev watchers).");
+
+    serve
+      .command("web")
+      .description("Start the built Next.js Codemation host (next start).")
+      .option("--consumer-root <path>", "Path to the consumer project root (defaults to cwd)")
+      .option(
+        "--no-source-maps",
+        "Disable .js.map files for emitted workflow modules when this command runs the consumer build step.",
+      )
+      .option(
+        "--target <es2020|es2022>",
+        "ECMAScript language version for emitted workflow JavaScript when building consumer output (default: es2022).",
+        "es2022",
+      )
+      .action(async (opts: Readonly<{ consumerRoot?: string; noSourceMaps?: boolean; target?: string }>) => {
+        await this.serveWebCommand.execute(resolveConsumerRoot(opts.consumerRoot), this.buildOptionsParser.parse(opts));
+      });
+
+    serve
+      .command("worker")
+      .description("Start the Codemation worker process.")
+      .option("--consumer-root <path>", "Path to the consumer project root (defaults to cwd)")
+      .option("--config <path>", "Override path to codemation.config.ts / .js")
+      .action(async (opts: Readonly<{ consumerRoot?: string; config?: string }>) => {
+        await this.serveWorkerCommand.execute(resolveConsumerRoot(opts.consumerRoot), opts.config);
+      });
+
+    const db = program.command("db").description("Database utilities (PostgreSQL / Prisma).");
+
+    db.command("migrate")
+      .description(
+        "Apply pending Prisma migrations using the consumer database URL (DATABASE_URL in `.env`, or CodemationConfig.runtime.database.url).",
+      )
+      .option("--consumer-root <path>", "Path to the consumer project root (defaults to cwd)")
+      .option("--config <path>", "Override path to codemation.config.ts / .js")
+      .action(async (opts: Readonly<{ consumerRoot?: string; config?: string }>) => {
+        await this.dbMigrateCommand.execute({
+          consumerRoot: resolveConsumerRoot(opts.consumerRoot),
+          configPath: opts.config,
+        });
+      });
+
+    const user = program.command("user").description("User administration (local auth)");
+
+    user
+      .command("create")
+      .description(
+        'Create or update a user in the database when CodemationConfig.auth.kind is "local". Uses DATABASE_URL or configured database URL.',
+      )
+      .requiredOption("--email <email>", "Login email")
+      .requiredOption("--password <password>", "Plain password (stored as a bcrypt hash)")
+      .option("--consumer-root <path>", "Path to the consumer project root (defaults to cwd)")
+      .option("--config <path>", "Override path to codemation.config.ts / .js")
+      .action(
+        async (
+          opts: Readonly<{
+            email: string;
+            password: string;
+            consumerRoot?: string;
+            config?: string;
+          }>,
+        ) => {
+          await this.userCreateCommand.execute(opts);
+        },
+      );
+
+    user
+      .command("list")
+      .description(
+        'List users in the database when CodemationConfig.auth.kind is "local". Uses DATABASE_URL or configured database URL.',
+      )
+      .option("--consumer-root <path>", "Path to the consumer project root (defaults to cwd)")
+      .option("--config <path>", "Override path to codemation.config.ts / .js")
+      .action(async (opts: Readonly<{ consumerRoot?: string; config?: string }>) => {
+        await this.userListCommand.execute(opts);
+      });
+
+    await program.parseAsync(argv as string[], { from: "user" });
+  }
+
+  private readCliPackageVersion(): string {
+    try {
+      const packageJsonPath = path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "package.json");
+      const parsed = JSON.parse(readFileSync(packageJsonPath, "utf8")) as { version?: unknown };
+      return typeof parsed.version === "string" ? parsed.version : "0.0.0";
+    } catch {
+      return "0.0.0";
+    }
+  }
+}

package/src/bin.ts

@@ -0,0 +1,6 @@
+import process from "node:process";
+import "reflect-metadata";
+
+import { CliBin } from "./CliBin";
+
+void CliBin.run(process.argv.slice(2));

package/src/bootstrap/CodemationCliApplicationSession.ts

@@ -0,0 +1,60 @@
+import { type Container } from "@codemation/core";
+import {
+  ApplicationTokens,
+  CodemationApplication,
+  CodemationBootstrapRequest,
+  PrismaClient,
+  type CommandBus,
+  type QueryBus,
+} from "@codemation/host";
+import type { CodemationConsumerConfigResolution } from "@codemation/host/server";
+
+/**
+ * Opens a {@link CodemationApplication} with persistence + command/query buses (no HTTP/WebSocket servers),
+ * for CLI tools that dispatch application commands or queries (e.g. user admin).
+ */
+export class CodemationCliApplicationSession {
+  private constructor(private readonly application: CodemationApplication) {}
+
+  static async open(
+    args: Readonly<{
+      resolution: CodemationConsumerConfigResolution;
+      bootstrap: CodemationBootstrapRequest;
+    }>,
+  ): Promise<CodemationCliApplicationSession> {
+    const app = new CodemationApplication().useConfig(args.resolution.config);
+    await app.bootCli(
+      new CodemationBootstrapRequest({
+        repoRoot: args.bootstrap.repoRoot,
+        consumerRoot: args.bootstrap.consumerRoot,
+        env: args.bootstrap.env,
+        workflowSources: args.resolution.workflowSources,
+      }),
+    );
+    return new CodemationCliApplicationSession(app);
+  }
+
+  getPrismaClient(): PrismaClient | undefined {
+    const container = this.getContainer();
+    if (!container.isRegistered(PrismaClient, true)) {
+      return undefined;
+    }
+    return container.resolve(PrismaClient);
+  }
+
+  getCommandBus(): CommandBus {
+    return this.getContainer().resolve(ApplicationTokens.CommandBus);
+  }
+
+  getQueryBus(): QueryBus {
+    return this.getContainer().resolve(ApplicationTokens.QueryBus);
+  }
+
+  async close(): Promise<void> {
+    await this.application.stop({ stopWebsocketServer: false });
+  }
+
+  private getContainer(): Container {
+    return this.application.getContainer();
+  }
+}

package/src/build/ConsumerBuildArtifactsPublisher.ts

@@ -0,0 +1,77 @@
+import type { CodemationDiscoveredPluginPackage } from "@codemation/host/server";
+import { randomUUID } from "node:crypto";
+import { mkdir, rename, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+
+import type { ConsumerOutputBuildSnapshot } from "../consumer/ConsumerOutputBuilder";
+
+export type ConsumerBuildManifest = Readonly<{
+  buildVersion: string;
+  consumerRoot: string;
+  entryPath: string;
+  manifestPath: string;
+  pluginEntryPath: string;
+  workflowSourcePaths: ReadonlyArray<string>;
+}>;
+
+export class ConsumerBuildArtifactsPublisher {
+  async publish(
+    snapshot: ConsumerOutputBuildSnapshot,
+    discoveredPlugins: ReadonlyArray<CodemationDiscoveredPluginPackage>,
+  ): Promise<ConsumerBuildManifest> {
+    const pluginEntryPath = await this.writeDiscoveredPluginsOutput(snapshot, discoveredPlugins);
+    return await this.writeBuildManifest(snapshot, pluginEntryPath);
+  }
+
+  private async writeDiscoveredPluginsOutput(
+    snapshot: ConsumerOutputBuildSnapshot,
+    discoveredPlugins: ReadonlyArray<CodemationDiscoveredPluginPackage>,
+  ): Promise<string> {
+    const outputPath = path.resolve(snapshot.emitOutputRoot, "plugins.js");
+    await mkdir(path.dirname(outputPath), { recursive: true });
+    const outputLines: string[] = ["const codemationDiscoveredPlugins = [];", ""];
+    discoveredPlugins.forEach((discoveredPlugin: CodemationDiscoveredPluginPackage, index: number) => {
+      const pluginFileUrl = pathToFileURL(
+        path.resolve(discoveredPlugin.packageRoot, discoveredPlugin.manifest.entry),
+      ).href;
+      const exportNameAccessor = discoveredPlugin.manifest.exportName
+        ? `pluginModule${index}[${JSON.stringify(discoveredPlugin.manifest.exportName)}]`
+        : `pluginModule${index}.default ?? pluginModule${index}.codemationPlugin`;
+      outputLines.push(`const pluginModule${index} = await import(${JSON.stringify(pluginFileUrl)});`);
+      outputLines.push(`const pluginValue${index} = ${exportNameAccessor};`);
+      outputLines.push(`if (pluginValue${index} && typeof pluginValue${index}.register === "function") {`);
+      outputLines.push(`  codemationDiscoveredPlugins.push(pluginValue${index});`);
+      outputLines.push(
+        `} else if (typeof pluginValue${index} === "function" && pluginValue${index}.prototype && typeof pluginValue${index}.prototype.register === "function") {`,
+      );
+      outputLines.push(`  codemationDiscoveredPlugins.push(new pluginValue${index}());`);
+      outputLines.push("}");
+      outputLines.push("");
+    });
+    outputLines.push("export { codemationDiscoveredPlugins };");
+    outputLines.push("export default codemationDiscoveredPlugins;");
+    outputLines.push("");
+    await writeFile(outputPath, outputLines.join("\n"), "utf8");
+    return outputPath;
+  }
+
+  private async writeBuildManifest(
+    snapshot: ConsumerOutputBuildSnapshot,
+    pluginEntryPath: string,
+  ): Promise<ConsumerBuildManifest> {
+    const manifest: ConsumerBuildManifest = {
+      buildVersion: snapshot.buildVersion,
+      consumerRoot: snapshot.consumerRoot,
+      entryPath: snapshot.outputEntryPath,
+      manifestPath: snapshot.manifestPath,
+      pluginEntryPath,
+      workflowSourcePaths: snapshot.workflowSourcePaths,
+    };
+    await mkdir(path.dirname(snapshot.manifestPath), { recursive: true });
+    const temporaryManifestPath = `${snapshot.manifestPath}.${snapshot.buildVersion}.${randomUUID()}.tmp`;
+    await writeFile(temporaryManifestPath, JSON.stringify(manifest, null, 2), "utf8");
+    await rename(temporaryManifestPath, snapshot.manifestPath);
+    return manifest;
+  }
+}

package/src/build/ConsumerBuildOptionsParser.ts

@@ -0,0 +1,26 @@
+import type { ConsumerBuildOptions, EcmaScriptBuildTarget } from "../consumer/consumerBuildOptions.types";
+
+export class ConsumerBuildOptionsParser {
+  parse(
+    args: Readonly<{
+      noSourceMaps?: boolean;
+      target?: string;
+    }>,
+  ): ConsumerBuildOptions {
+    return {
+      sourceMaps: args.noSourceMaps !== true,
+      target: this.parseTarget(args.target),
+    };
+  }
+
+  private parseTarget(raw: string | undefined): EcmaScriptBuildTarget {
+    if (raw === undefined || raw.trim() === "") {
+      return "es2022";
+    }
+    const normalized = raw.trim();
+    if (normalized === "es2020" || normalized === "es2022") {
+      return normalized;
+    }
+    throw new Error(`Invalid --target "${raw}". Use es2020 or es2022.`);
+  }
+}

package/src/commands/BuildCommand.ts

@@ -0,0 +1,31 @@
+import type { Logger } from "@codemation/host/next/server";
+import { CodemationPluginDiscovery } from "@codemation/host/server";
+
+import { ConsumerBuildArtifactsPublisher } from "../build/ConsumerBuildArtifactsPublisher";
+import type { ConsumerBuildOptions } from "../consumer/consumerBuildOptions.types";
+import { ConsumerOutputBuilderLoader } from "../consumer/Loader";
+import { CliPathResolver } from "../path/CliPathResolver";
+import { TypeScriptRuntimeConfigurator } from "../runtime/TypeScriptRuntimeConfigurator";
+
+export class BuildCommand {
+  constructor(
+    private readonly cliLogger: Logger,
+    private readonly pathResolver: CliPathResolver,
+    private readonly pluginDiscovery: CodemationPluginDiscovery,
+    private readonly artifactsPublisher: ConsumerBuildArtifactsPublisher,
+    private readonly tsRuntime: TypeScriptRuntimeConfigurator,
+    private readonly outputBuilderLoader: ConsumerOutputBuilderLoader,
+  ) {}
+
+  async execute(consumerRoot: string, buildOptions: ConsumerBuildOptions): Promise<void> {
+    const paths = await this.pathResolver.resolve(consumerRoot);
+    this.tsRuntime.configure(paths.repoRoot);
+    const builder = this.outputBuilderLoader.create(paths.consumerRoot, buildOptions);
+    const snapshot = await builder.ensureBuilt();
+    const discoveredPlugins = await this.pluginDiscovery.discover(paths.consumerRoot);
+    const manifest = await this.artifactsPublisher.publish(snapshot, discoveredPlugins);
+    this.cliLogger.info(`Built consumer output: ${snapshot.outputEntryPath}`);
+    this.cliLogger.info(`Discovered plugins: ${discoveredPlugins.length}`);
+    this.cliLogger.info(`Published build: ${manifest.buildVersion}`);
+  }
+}

package/src/commands/DbMigrateCommand.ts

@@ -0,0 +1,19 @@
+import type { DatabaseMigrationsApplyService } from "../database/DatabaseMigrationsApplyService";
+
+export type DbMigrateCommandOptions = Readonly<{
+  consumerRoot?: string;
+  configPath?: string;
+}>;
+
+export class DbMigrateCommand {
+  constructor(private readonly databaseMigrationsApplyService: DatabaseMigrationsApplyService) {}
+
+  async execute(options: DbMigrateCommandOptions): Promise<void> {
+    await this.databaseMigrationsApplyService.applyForConsumerRequiringPersistence(
+      options.consumerRoot ?? process.cwd(),
+      {
+        configPath: options.configPath,
+      },
+    );
+  }
+}