@codemation/cli 0.0.5 → 0.0.11

package/src/dev/DevApiRuntimeServer.ts

@@ -0,0 +1,107 @@
+import { CodemationHonoApiApp, ServerLoggerFactory, logLevelPolicyFactory } from "@codemation/host/next/server";
+import { serve } from "@hono/node-server";
+import { Hono } from "hono";
+
+import type { DevApiRuntimeContext } from "./DevApiRuntimeTypes";
+import type { DevApiRuntimeHost } from "./DevApiRuntimeHost";
+
+type ClosableServer = Readonly<{
+  close(callback?: (error?: Error) => void): unknown;
+}>;
+
+export class DevApiRuntimeServer {
+  private readonly bootstrapLogger = new ServerLoggerFactory(logLevelPolicyFactory).create(
+    "codemation-cli.dev-runtime",
+  );
+  private server: ClosableServer | null = null;
+
+  constructor(
+    private readonly httpPort: number,
+    private readonly workflowWebSocketPort: number,
+    private readonly host: DevApiRuntimeHost,
+  ) {}
+
+  async start(): Promise<DevApiRuntimeContext> {
+    const root = new Hono();
+    root.get("/health", (c) => c.json({ ok: true }));
+    root.all("*", async (c) => {
+      const context = await this.host.prepare();
+      return context.container.resolve(CodemationHonoApiApp).fetch(c.req.raw);
+    });
+    await this.listen(root);
+    try {
+      return await this.host.prepare();
+    } catch (error) {
+      await this.stop();
+      throw error;
+    }
+  }
+
+  async stop(): Promise<void> {
+    const server = this.server;
+    this.server = null;
+    const failures: Error[] = [];
+    if (server) {
+      try {
+        await this.closeServer(server);
+      } catch (error) {
+        failures.push(this.normalizeError(error));
+      }
+    }
+    try {
+      await this.host.stop();
+    } catch (error) {
+      failures.push(this.normalizeError(error));
+    }
+    if (failures.length > 0) {
+      throw failures[0];
+    }
+  }
+
+  private async listen(root: Hono): Promise<void> {
+    if (this.server) {
+      return;
+    }
+    await new Promise<void>((resolve, reject) => {
+      let resolved = false;
+      const server = serve(
+        {
+          fetch: root.fetch,
+          port: this.httpPort,
+          hostname: "127.0.0.1",
+        },
+        () => {
+          resolved = true;
+          this.server = server;
+          resolve();
+        },
+      );
+      server.on("error", (error) => {
+        if (resolved) {
+          this.bootstrapLogger.error("runtime HTTP server error", this.normalizeError(error));
+          return;
+        }
+        reject(error);
+      });
+    });
+    this.bootstrapLogger.debug(
+      `runtime listening httpPort=${this.httpPort} workflowWebSocketPort=${this.workflowWebSocketPort}`,
+    );
+  }
+
+  private closeServer(server: ClosableServer): Promise<void> {
+    return new Promise<void>((resolve, reject) => {
+      server.close((error) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve();
+      });
+    });
+  }
+
+  private normalizeError(error: unknown): Error {
+    return error instanceof Error ? error : new Error(String(error));
+  }
+}

package/src/dev/DevApiRuntimeTypes.ts

@@ -0,0 +1,24 @@
+import type { Container } from "@codemation/core";
+
+export type DevApiRuntimeContext = Readonly<{
+  buildVersion: string;
+  container: Container;
+  consumerRoot: string;
+  repoRoot: string;
+  workflowIds: ReadonlyArray<string>;
+  workflowSources: ReadonlyArray<string>;
+}>;
+
+export type DevApiRuntimeFactoryArgs = Readonly<{
+  consumerRoot: string;
+  env: NodeJS.ProcessEnv;
+  runtimeWorkingDirectory: string;
+}>;
+
+export type DevApiRuntimeServerHandle = Readonly<{
+  buildVersion: string;
+  httpPort: number;
+  stop: () => Promise<void>;
+  workflowIds: ReadonlyArray<string>;
+  workflowWebSocketPort: number;
+}>;

package/src/dev/DevAuthSettingsLoader.ts

@@ -2,6 +2,8 @@ import { randomUUID } from "node:crypto";
 
 import { CodemationConsumerConfigLoader } from "@codemation/host/server";
 
+import type { ConsumerEnvLoader } from "../consumer/ConsumerEnvLoader";
+
 export type DevResolvedAuthSettings = Readonly<{
   authConfigJson: string;
   authSecret: string;
@@ -11,7 +13,10 @@ export type DevResolvedAuthSettings = Readonly<{
 export class DevAuthSettingsLoader {
   static readonly defaultDevelopmentAuthSecret = "codemation-dev-auth-secret-not-for-production";
 
-  constructor(private readonly configLoader: CodemationConsumerConfigLoader) {}
+  constructor(
+    private readonly configLoader: CodemationConsumerConfigLoader,
+    private readonly consumerEnvLoader: ConsumerEnvLoader,
+  ) {}
 
   resolveDevelopmentServerToken(rawToken: string | undefined): string {
     if (rawToken && rawToken.trim().length > 0) {
@@ -22,15 +27,16 @@ export class DevAuthSettingsLoader {
 
   async loadForConsumer(consumerRoot: string): Promise<DevResolvedAuthSettings> {
     const resolution = await this.configLoader.load({ consumerRoot });
+    const envForAuthSecret = this.consumerEnvLoader.mergeConsumerRootIntoProcessEnvironment(consumerRoot, process.env);
     return {
       authConfigJson: JSON.stringify(resolution.config.auth ?? null),
-      authSecret: this.resolveDevelopmentAuthSecret(process.env),
+      authSecret: this.resolveDevelopmentAuthSecret(envForAuthSecret),
       skipUiAuth: resolution.config.auth?.allowUnauthenticatedInDevelopment === true,
     };
   }
 
   resolveDevelopmentAuthSecret(env: NodeJS.ProcessEnv): string {
-    const configuredSecret = env.AUTH_SECRET ?? env.NEXTAUTH_SECRET;
+    const configuredSecret = env.AUTH_SECRET;
     if (configuredSecret && configuredSecret.trim().length > 0) {
       return configuredSecret;
     }

package/src/dev/DevBootstrapSummaryFetcher.ts

@@ -1,7 +1,7 @@
 import type { DevBootstrapSummaryJson } from "@codemation/host/next/server";
 
 /**
- * Fetches {@link DevBootstrapSummaryJson} from the dev gateway (proxied to runtime-dev).
+ * Fetches {@link DevBootstrapSummaryJson} from the stable CLI-owned dev endpoint.
  */
 export class DevBootstrapSummaryFetcher {
   async fetch(gatewayBaseUrl: string): Promise<DevBootstrapSummaryJson | null> {

package/src/dev/DevHttpProbe.ts

@@ -29,11 +29,11 @@ export class DevHttpProbe {
       }
       await delay(50);
     }
-    throw new Error("Timed out waiting for dev gateway HTTP health check.");
+    throw new Error("Timed out waiting for the stable dev HTTP health check.");
   }
 
   /**
-   * Polls until the runtime child serves bootstrap summary (after gateway is up, the disposable runtime may still be wiring).
+   * Polls until the active disposable runtime serves bootstrap summary through the stable CLI dev endpoint.
    */
   async waitUntilBootstrapSummaryReady(gatewayBaseUrl: string): Promise<void> {
     const normalizedBase = gatewayBaseUrl.replace(/\/$/, "");

package/src/dev/DevNextHostEnvironmentBuilder.ts

@@ -1,5 +1,7 @@
 import path from "node:path";
 import process from "node:process";
+import type { CodemationAuthConfig } from "@codemation/host";
+import { CodemationFrontendAuthSnapshotFactory, FrontendAppConfigJsonCodec } from "@codemation/host";
 
 import { ConsumerEnvLoader } from "../consumer/ConsumerEnvLoader";
 import { SourceMapNodeOptions } from "../runtime/SourceMapNodeOptions";
@@ -8,6 +10,8 @@ export class DevNextHostEnvironmentBuilder {
   constructor(
     private readonly consumerEnvLoader: ConsumerEnvLoader,
     private readonly sourceMapNodeOptions: SourceMapNodeOptions,
+    private readonly frontendAuthSnapshotFactory: CodemationFrontendAuthSnapshotFactory = new CodemationFrontendAuthSnapshotFactory(),
+    private readonly frontendAppConfigJsonCodec: FrontendAppConfigJsonCodec = new FrontendAppConfigJsonCodec(),
   ) {}
 
   buildConsumerUiProxy(
@@ -27,6 +31,7 @@ export class DevNextHostEnvironmentBuilder {
     return {
       ...this.build({
         authConfigJson: args.authConfigJson,
+        authSecret: args.authSecret,
         consumerRoot: args.consumerRoot,
         developmentServerToken: args.developmentServerToken,
         nextPort: args.nextPort,
@@ -35,16 +40,18 @@ export class DevNextHostEnvironmentBuilder {
         websocketPort: args.websocketPort,
         consumerOutputManifestPath: args.consumerOutputManifestPath,
       }),
+      // Standalone `server.js` uses `process.env.HOSTNAME || '0.0.0.0'` for bind; Docker sets HOSTNAME to the
+      // container id, which breaks loopback health checks — force IPv4 loopback for the UI child only.
+      HOSTNAME: "127.0.0.1",
       AUTH_SECRET: args.authSecret,
       AUTH_URL: args.publicBaseUrl,
-      NEXTAUTH_SECRET: args.authSecret,
-      NEXTAUTH_URL: args.publicBaseUrl,
     };
   }
 
   build(
     args: Readonly<{
       authConfigJson: string;
+      authSecret?: string;
       consumerRoot: string;
       developmentServerToken: string;
       nextPort: number;
@@ -58,14 +65,29 @@ export class DevNextHostEnvironmentBuilder {
     const merged = this.consumerEnvLoader.mergeConsumerRootIntoProcessEnvironment(args.consumerRoot, process.env);
     const manifestPath =
       args.consumerOutputManifestPath ?? path.resolve(args.consumerRoot, ".codemation", "output", "current.json");
+    const authSecret = args.authSecret ?? merged.AUTH_SECRET;
+    const authSnapshot = this.frontendAuthSnapshotFactory.createFromResolvedInputs({
+      authConfig: this.parseAuthConfig(args.authConfigJson),
+      env: {
+        ...merged,
+        ...(typeof authSecret === "string" && authSecret.trim().length > 0
+          ? {
+              AUTH_SECRET: authSecret,
+            }
+          : {}),
+      },
+      uiAuthEnabled: !args.skipUiAuth,
+    });
     return {
       ...merged,
       PORT: String(args.nextPort),
-      CODEMATION_AUTH_CONFIG_JSON: args.authConfigJson,
       CODEMATION_CONSUMER_ROOT: args.consumerRoot,
       CODEMATION_CONSUMER_OUTPUT_MANIFEST_PATH: manifestPath,
-      CODEMATION_SKIP_UI_AUTH: args.skipUiAuth ? "true" : "false",
-      NEXT_PUBLIC_CODEMATION_SKIP_UI_AUTH: args.skipUiAuth ? "true" : "false",
+      CODEMATION_FRONTEND_APP_CONFIG_JSON: this.frontendAppConfigJsonCodec.serialize({
+        auth: authSnapshot,
+        productName: "Codemation",
+        logoUrl: null,
+      }),
       CODEMATION_WS_PORT: String(args.websocketPort),
       NEXT_PUBLIC_CODEMATION_WS_PORT: String(args.websocketPort),
       CODEMATION_DEV_SERVER_TOKEN: args.developmentServerToken,
@@ -78,4 +100,12 @@ export class DevNextHostEnvironmentBuilder {
         : {}),
     };
   }
+
+  private parseAuthConfig(authConfigJson: string): CodemationAuthConfig | undefined {
+    if (authConfigJson.trim().length === 0) {
+      return undefined;
+    }
+    const parsed = JSON.parse(authConfigJson) as CodemationAuthConfig | null;
+    return parsed ?? undefined;
+  }
 }

package/src/dev/DevRebuildQueue.ts

@@ -0,0 +1,54 @@
+export type DevRebuildRequest = Readonly<{
+  changedPaths: ReadonlyArray<string>;
+  shouldRepublishConsumerOutput: boolean;
+  shouldRestartUi: boolean;
+}>;
+
+export interface DevRebuildHandler {
+  run(request: DevRebuildRequest): Promise<void>;
+}
+
+export class DevRebuildQueue {
+  private pendingRequest: DevRebuildRequest | null = null;
+  private drainPromise: Promise<void> | null = null;
+
+  constructor(private readonly handler: DevRebuildHandler) {}
+
+  async enqueue(request: DevRebuildRequest): Promise<void> {
+    this.pendingRequest = this.mergePendingRequest(this.pendingRequest, request);
+    if (!this.drainPromise) {
+      this.drainPromise = this.drain();
+    }
+    return await this.drainPromise;
+  }
+
+  private async drain(): Promise<void> {
+    try {
+      while (this.pendingRequest) {
+        const nextRequest = this.pendingRequest;
+        this.pendingRequest = null;
+        await this.handler.run(nextRequest);
+      }
+    } finally {
+      this.drainPromise = null;
+      if (this.pendingRequest) {
+        this.drainPromise = this.drain();
+        await this.drainPromise;
+      }
+    }
+  }
+
+  private mergePendingRequest(current: DevRebuildRequest | null, next: DevRebuildRequest): DevRebuildRequest {
+    if (!current) {
+      return {
+        ...next,
+        changedPaths: [...next.changedPaths],
+      };
+    }
+    return {
+      changedPaths: [...new Set([...current.changedPaths, ...next.changedPaths])],
+      shouldRepublishConsumerOutput: current.shouldRepublishConsumerOutput || next.shouldRepublishConsumerOutput,
+      shouldRestartUi: current.shouldRestartUi || next.shouldRestartUi,
+    };
+  }
+}

package/src/dev/DevRebuildQueueFactory.ts

@@ -0,0 +1,7 @@
+import { DevRebuildQueue, type DevRebuildHandler } from "./DevRebuildQueue";
+
+export class DevRebuildQueueFactory {
+  create(handler: DevRebuildHandler): DevRebuildQueue {
+    return new DevRebuildQueue(handler);
+  }
+}

package/src/dev/DevSessionPortsResolver.ts

@@ -9,7 +9,7 @@ export class DevSessionPortsResolver {
 
   async resolve(
     args: Readonly<{
-      devMode: "consumer" | "framework";
+      devMode: "packaged-ui" | "watch-framework";
       portEnv: string | undefined;
       gatewayPortEnv: string | undefined;
     }>,
@@ -17,7 +17,7 @@ export class DevSessionPortsResolver {
     const nextPort = this.listenPorts.resolvePrimaryApplicationPort(args.portEnv);
     const gatewayPort =
       this.listenPorts.parsePositiveInteger(args.gatewayPortEnv) ??
-      (args.devMode === "consumer" ? nextPort : await this.loopbackPorts.allocate());
+      (args.devMode === "packaged-ui" ? nextPort : await this.loopbackPorts.allocate());
     return { nextPort, gatewayPort };
   }
 }

package/src/dev/DevSessionServices.ts

@@ -6,9 +6,7 @@ import { DevHttpProbe } from "./DevHttpProbe";
 import { DevNextHostEnvironmentBuilder } from "./DevNextHostEnvironmentBuilder";
 import { DevSessionPortsResolver } from "./DevSessionPortsResolver";
 import { DevSourceChangeClassifier } from "./DevSourceChangeClassifier";
-import { DevSourceRestartCoordinator } from "./DevSourceRestartCoordinator";
 import { LoopbackPortAllocator } from "./LoopbackPortAllocator";
-import { RuntimeToolEntrypointResolver } from "./RuntimeToolEntrypointResolver";
 import { WatchRootsResolver } from "./WatchRootsResolver";
 
 /**
@@ -21,11 +19,9 @@ export class DevSessionServices {
     readonly sessionPorts: DevSessionPortsResolver,
     readonly loopbackPortAllocator: LoopbackPortAllocator,
     readonly devHttpProbe: DevHttpProbe,
-    readonly runtimeEntrypointResolver: RuntimeToolEntrypointResolver,
     readonly devAuthLoader: DevAuthSettingsLoader,
     readonly nextHostEnvBuilder: DevNextHostEnvironmentBuilder,
     readonly watchRootsResolver: WatchRootsResolver,
     readonly sourceChangeClassifier: DevSourceChangeClassifier,
-    readonly sourceRestartCoordinator: DevSourceRestartCoordinator,
   ) {}
 }

package/src/dev/DevSourceChangeClassifier.ts

@@ -1,6 +1,12 @@
 import path from "node:path";
 
 export class DevSourceChangeClassifier {
+  private static readonly configFileNames = new Set([
+    "codemation.config.ts",
+    "codemation.config.js",
+    "codemation.config.mjs",
+  ]);
+
   shouldRepublishConsumerOutput(
     args: Readonly<{
       changedPaths: ReadonlyArray<string>;
@@ -11,24 +17,16 @@ export class DevSourceChangeClassifier {
     return args.changedPaths.some((changedPath) => this.isPathInsideDirectory(changedPath, resolvedConsumerRoot));
   }
 
-  requiresNextHostRestart(
+  requiresUiRestart(
     args: Readonly<{
       changedPaths: ReadonlyArray<string>;
       consumerRoot: string;
     }>,
   ): boolean {
-    const configPaths = new Set(this.resolveConfigPaths(args.consumerRoot));
-    return args.changedPaths.some((changedPath) => configPaths.has(path.resolve(changedPath)));
-  }
-
-  private resolveConfigPaths(consumerRoot: string): ReadonlyArray<string> {
-    const resolvedConsumerRoot = path.resolve(consumerRoot);
-    return [
-      path.resolve(resolvedConsumerRoot, "codemation.config.ts"),
-      path.resolve(resolvedConsumerRoot, "codemation.config.js"),
-      path.resolve(resolvedConsumerRoot, "src", "codemation.config.ts"),
-      path.resolve(resolvedConsumerRoot, "src", "codemation.config.js"),
-    ];
+    const resolvedConsumerRoot = path.resolve(args.consumerRoot);
+    return args.changedPaths.some((changedPath) =>
+      this.pathRequiresUiRestart(path.resolve(changedPath), resolvedConsumerRoot),
+    );
   }
 
   private isPathInsideDirectory(filePath: string, directoryPath: string): boolean {
@@ -36,4 +34,26 @@ export class DevSourceChangeClassifier {
     const relativePath = path.relative(directoryPath, resolvedFilePath);
     return relativePath.length === 0 || (!relativePath.startsWith("..") && !path.isAbsolute(relativePath));
   }
+
+  private pathRequiresUiRestart(resolvedPath: string, consumerRoot: string): boolean {
+    if (!this.isPathInsideDirectory(resolvedPath, consumerRoot)) {
+      return false;
+    }
+    const relativePath = path.relative(consumerRoot, resolvedPath);
+    if (DevSourceChangeClassifier.configFileNames.has(path.basename(relativePath))) {
+      // Config changes affect auth and branding projections consumed by the packaged Next host.
+      return true;
+    }
+    if (relativePath.startsWith(path.join("src", "workflows"))) {
+      return false;
+    }
+    if (relativePath.startsWith(path.join("src", "plugins"))) {
+      return false;
+    }
+    if (relativePath.includes("credential")) {
+      // Credential type edits still require a packaged UI restart until the credentials screen live-refreshes.
+      return true;
+    }
+    return false;
+  }
 }

package/src/dev/ListenPortConflictDescriber.ts

@@ -0,0 +1,83 @@
+import { execFile } from "node:child_process";
+import process from "node:process";
+
+type PortOccupant = Readonly<{
+  pid: number;
+  command: string;
+  endpoint: string;
+}>;
+
+export class ListenPortConflictDescriber {
+  constructor(private readonly platform: NodeJS.Platform = process.platform) {}
+
+  async describeLoopbackPort(port: number): Promise<string | null> {
+    if (!Number.isInteger(port) || port <= 0) {
+      return null;
+    }
+    if (this.platform !== "linux" && this.platform !== "darwin") {
+      return null;
+    }
+
+    const raw = await this.readLsofOutput(port);
+    if (raw === null) {
+      return null;
+    }
+    const occupants = this.parseLsofOutput(raw);
+    if (occupants.length === 0) {
+      return null;
+    }
+
+    return occupants
+      .map((occupant) => `pid=${occupant.pid} command=${occupant.command} endpoint=${occupant.endpoint}`)
+      .join("; ");
+  }
+
+  private async readLsofOutput(port: number): Promise<string | null> {
+    try {
+      return await new Promise<string>((resolve, reject) => {
+        execFile("lsof", ["-nP", `-iTCP:${port}`, "-sTCP:LISTEN", "-Fpcn"], (error, stdout) => {
+          if (error) {
+            reject(error);
+            return;
+          }
+          resolve(stdout);
+        });
+      });
+    } catch {
+      return null;
+    }
+  }
+
+  private parseLsofOutput(raw: string): ReadonlyArray<PortOccupant> {
+    const occupants: PortOccupant[] = [];
+    let currentPid: number | null = null;
+    let currentCommand: string | null = null;
+
+    for (const line of raw.split("\n")) {
+      if (line.length < 2) {
+        continue;
+      }
+      const prefix = line[0];
+      const value = line.slice(1).trim();
+
+      if (prefix === "p") {
+        currentPid = Number.parseInt(value, 10);
+        currentCommand = null;
+        continue;
+      }
+      if (prefix === "c") {
+        currentCommand = value;
+        continue;
+      }
+      if (prefix === "n" && currentPid !== null && currentCommand !== null) {
+        occupants.push({
+          pid: currentPid,
+          command: currentCommand,
+          endpoint: value,
+        });
+      }
+    }
+
+    return occupants;
+  }
+}

package/src/dev/WatchRootsResolver.ts

@@ -4,23 +4,25 @@ export class WatchRootsResolver {
   resolve(
     args: Readonly<{
       consumerRoot: string;
-      devMode: "consumer" | "framework";
+      devMode: "packaged-ui" | "watch-framework";
       repoRoot: string;
     }>,
   ): ReadonlyArray<string> {
-    if (args.devMode === "consumer") {
+    if (args.devMode === "packaged-ui") {
+      // Packaged UI mode watches only the app itself. Framework packages are consumed from their built output.
       return [args.consumerRoot];
     }
+    // Watch-framework mode is framework-author development: watch the app plus the workspace packages that
+    // feed the consumer output and packaged Next host.
     return [
       args.consumerRoot,
+      path.resolve(args.repoRoot, "packages", "cli"),
       path.resolve(args.repoRoot, "packages", "core"),
       path.resolve(args.repoRoot, "packages", "core-nodes"),
       path.resolve(args.repoRoot, "packages", "core-nodes-gmail"),
       path.resolve(args.repoRoot, "packages", "eventbus-redis"),
       path.resolve(args.repoRoot, "packages", "host"),
       path.resolve(args.repoRoot, "packages", "node-example"),
-      path.resolve(args.repoRoot, "packages", "queue-bullmq"),
-      path.resolve(args.repoRoot, "packages", "runtime-dev"),
     ];
   }
 }

package/src/runtime/NextHostConsumerServerCommandFactory.ts

@@ -10,7 +10,14 @@ export type NextHostConsumerServerCommand = Readonly<{
 
 export class NextHostConsumerServerCommandFactory {
   async create(args: Readonly<{ nextHostRoot: string }>): Promise<NextHostConsumerServerCommand> {
-    const standaloneServerPath = path.resolve(args.nextHostRoot, ".next", "standalone", "packages", "next-host", "server.js");
+    const standaloneServerPath = path.resolve(
+      args.nextHostRoot,
+      ".next",
+      "standalone",
+      "packages",
+      "next-host",
+      "server.js",
+    );
     if (await this.exists(standaloneServerPath)) {
       return {
         command: process.execPath,
@@ -20,7 +27,9 @@ export class NextHostConsumerServerCommandFactory {
     }
     return {
       command: "pnpm",
-      args: ["exec", "next", "start"],
+      // Bind loopback so `codemation dev` health probes (`http://127.0.0.1:<port>`) work in Docker,
+      // where `process.env.HOSTNAME` is the container id and would otherwise be used by `next start`.
+      args: ["exec", "next", "start", "-H", "127.0.0.1"],
       cwd: args.nextHostRoot,
     };
   }

package/src/user/CliDatabaseUrlDescriptor.ts

@@ -1,10 +1,10 @@
-import type { ResolvedDatabasePersistence } from "@codemation/host/persistence";
+import type { AppPersistenceConfig } from "@codemation/host/persistence";
 
 /**
  * Formats a database URL for CLI messages without exposing credentials (no user/password).
  */
 export class CliDatabaseUrlDescriptor {
-  describePersistence(persistence: ResolvedDatabasePersistence): string {
+  describePersistence(persistence: AppPersistenceConfig): string {
     if (persistence.kind === "none") {
       return "none";
     }

package/src/user/UserAdminCliBootstrap.ts

@@ -1,6 +1,4 @@
-import { CodemationBootstrapRequest } from "@codemation/host";
-import { DatabasePersistenceResolver } from "@codemation/host/persistence";
-import { CodemationConsumerConfigLoader } from "@codemation/host/server";
+import { AppConfigLoader } from "@codemation/host/server";
 
 import { CodemationCliApplicationSession } from "../bootstrap/CodemationCliApplicationSession";
 import type { ConsumerCliTsconfigPreparation } from "../consumer/ConsumerCliTsconfigPreparation";
@@ -17,11 +15,10 @@ export type UserAdminCliOptions = Readonly<{
  */
 export class UserAdminCliBootstrap {
   constructor(
-    private readonly configLoader: CodemationConsumerConfigLoader,
+    private readonly appConfigLoader: AppConfigLoader,
     private readonly pathResolver: CliPathResolver,
     private readonly consumerDotenvLoader: UserAdminConsumerDotenvLoader,
     private readonly tsconfigPreparation: ConsumerCliTsconfigPreparation,
-    private readonly databasePersistenceResolver: DatabasePersistenceResolver,
   ) {}
 
   async withSession<T>(
@@ -31,32 +28,23 @@ export class UserAdminCliBootstrap {
     const consumerRoot = options.consumerRoot ?? process.cwd();
     this.consumerDotenvLoader.load(consumerRoot);
     this.tsconfigPreparation.applyWorkspaceTsconfigForTsxIfPresent(consumerRoot);
-    const resolution = await this.configLoader.load({
+    const paths = await this.pathResolver.resolve(consumerRoot);
+    const loadResult = await this.appConfigLoader.load({
       consumerRoot,
+      repoRoot: paths.repoRoot,
+      env: process.env,
       configPathOverride: options.configPath,
     });
-    if (resolution.config.auth?.kind !== "local") {
+    if (loadResult.appConfig.auth?.kind !== "local") {
       throw new Error('Codemation user commands require CodemationConfig.auth.kind to be "local".');
     }
-    const persistence = this.databasePersistenceResolver.resolve({
-      runtimeConfig: resolution.config.runtime ?? {},
-      env: process.env,
-      consumerRoot,
-    });
-    if (persistence.kind === "none") {
+    if (loadResult.appConfig.persistence.kind === "none") {
       throw new Error(
         "Database persistence is not configured. Set CodemationConfig.runtime.database (postgresql URL or PGlite).",
       );
     }
-    const paths = await this.pathResolver.resolve(consumerRoot);
     const session = await CodemationCliApplicationSession.open({
-      resolution,
-      bootstrap: new CodemationBootstrapRequest({
-        repoRoot: paths.repoRoot,
-        consumerRoot,
-        env: process.env,
-        workflowSources: resolution.workflowSources,
-      }),
+      appConfig: loadResult.appConfig,
     });
     try {
       return await fn(session);