@codemation/cli 0.0.5 → 0.0.11

package/src/commands/ServeWebCommand.ts

@@ -1,4 +1,9 @@
-import { CodemationPluginDiscovery } from "@codemation/host/server";
+import {
+  CodemationConsumerConfigLoader,
+  CodemationFrontendAuthSnapshotFactory,
+  CodemationPluginDiscovery,
+  FrontendAppConfigJsonCodec,
+} from "@codemation/host/server";
 import { spawn } from "node:child_process";
 import { createRequire } from "node:module";
 import path from "node:path";
@@ -19,6 +24,7 @@ export class ServeWebCommand {
 
   constructor(
     private readonly pathResolver: CliPathResolver,
+    private readonly configLoader: CodemationConsumerConfigLoader,
     private readonly pluginDiscovery: CodemationPluginDiscovery,
     private readonly artifactsPublisher: ConsumerBuildArtifactsPublisher,
     private readonly tsRuntime: TypeScriptRuntimeConfigurator,
@@ -27,6 +33,8 @@ export class ServeWebCommand {
     private readonly envLoader: ConsumerEnvLoader,
     private readonly listenPortResolver: ListenPortResolver,
     private readonly nextHostConsumerServerCommandFactory: NextHostConsumerServerCommandFactory,
+    private readonly frontendAuthSnapshotFactory: CodemationFrontendAuthSnapshotFactory,
+    private readonly frontendAppConfigJsonCodec: FrontendAppConfigJsonCodec,
   ) {}
 
   async execute(consumerRoot: string, buildOptions: ConsumerBuildOptions): Promise<void> {
@@ -39,6 +47,18 @@ export class ServeWebCommand {
     const nextHostRoot = path.dirname(this.require.resolve("@codemation/next-host/package.json"));
     const nextHostCommand = await this.nextHostConsumerServerCommandFactory.create({ nextHostRoot });
     const consumerEnv = this.envLoader.load(paths.consumerRoot);
+    const configResolution = await this.configLoader.load({ consumerRoot: paths.consumerRoot });
+    const frontendAuthSnapshot = this.frontendAuthSnapshotFactory.createFromResolvedInputs({
+      authConfig: configResolution.config.auth,
+      env: {
+        ...process.env,
+        ...consumerEnv,
+      },
+      uiAuthEnabled: !(
+        consumerEnv.NODE_ENV !== "production" &&
+        configResolution.config.auth?.allowUnauthenticatedInDevelopment === true
+      ),
+    });
     const nextPort = this.listenPortResolver.resolvePrimaryApplicationPort(process.env.PORT);
     const websocketPort = this.listenPortResolver.resolveWebsocketPortRelativeToHttp({
       nextPort,
@@ -52,6 +72,11 @@ export class ServeWebCommand {
         ...process.env,
         ...consumerEnv,
         PORT: String(nextPort),
+        CODEMATION_FRONTEND_APP_CONFIG_JSON: this.frontendAppConfigJsonCodec.serialize({
+          auth: frontendAuthSnapshot,
+          productName: "Codemation",
+          logoUrl: null,
+        }),
         CODEMATION_CONSUMER_OUTPUT_MANIFEST_PATH: manifest.manifestPath,
         CODEMATION_CONSUMER_ROOT: paths.consumerRoot,
         CODEMATION_WS_PORT: String(websocketPort),

package/src/commands/ServeWorkerCommand.ts

@@ -1,40 +1,56 @@
-import { spawn } from "node:child_process";
-import { createRequire } from "node:module";
-import path from "node:path";
+import { AppContainerFactory, WorkerRuntime } from "@codemation/host";
+import { AppConfigLoader } from "@codemation/host/server";
 import process from "node:process";
-
-import { SourceMapNodeOptions } from "../runtime/SourceMapNodeOptions";
+import { CliPathResolver } from "../path/CliPathResolver";
 
 export class ServeWorkerCommand {
-  private readonly require = createRequire(import.meta.url);
-
-  constructor(private readonly sourceMapNodeOptions: SourceMapNodeOptions) {}
+  constructor(
+    private readonly pathResolver: CliPathResolver,
+    private readonly appConfigLoader: AppConfigLoader,
+    private readonly appContainerFactory: AppContainerFactory,
+  ) {}
 
   async execute(consumerRoot: string, configPathOverride?: string): Promise<void> {
-    const workerPackageRoot = path.dirname(this.require.resolve("@codemation/worker-cli/package.json"));
-    const workerBin = path.join(workerPackageRoot, "bin", "codemation-worker.js");
-    const args = [workerBin];
-    if (configPathOverride !== undefined && configPathOverride.trim().length > 0) {
-      args.push("--config", path.resolve(process.cwd(), configPathOverride.trim()));
+    const paths = await this.pathResolver.resolve(consumerRoot);
+    const loadResult = await this.appConfigLoader.load({
+      consumerRoot,
+      repoRoot: paths.repoRoot,
+      env: process.env,
+      configPathOverride,
+    });
+    if (loadResult.appConfig.scheduler.kind !== "bullmq") {
+      throw new Error('Worker mode requires runtime.scheduler.kind = "bullmq".');
     }
-    args.push("--consumer-root", consumerRoot);
-    const child = spawn(process.execPath, args, {
-      cwd: consumerRoot,
-      stdio: "inherit",
-      env: {
-        ...process.env,
-        NODE_OPTIONS: this.sourceMapNodeOptions.appendToNodeOptions(process.env.NODE_OPTIONS),
-      },
+    const container = await this.appContainerFactory.create({
+      appConfig: loadResult.appConfig,
+      sharedWorkflowWebsocketServer: null,
     });
-    await new Promise<void>((resolve, reject) => {
-      child.on("exit", (code) => {
-        if ((code ?? 0) === 0) {
-          resolve();
-          return;
-        }
-        reject(new Error(`codemation-worker exited with code ${code ?? 0}.`));
-      });
-      child.on("error", reject);
+    const workerQueues =
+      loadResult.appConfig.scheduler.workerQueues.length > 0
+        ? loadResult.appConfig.scheduler.workerQueues
+        : ["default"];
+    const handle = await container.resolve(WorkerRuntime).start(workerQueues);
+    await new Promise<void>((resolve) => {
+      this.bindSignals(handle.stop, resolve);
     });
   }
+
+  private bindSignals(stop: () => Promise<void>, resolve: () => void): void {
+    let stopping = false;
+    const onSignal = async (): Promise<void> => {
+      if (stopping) {
+        return;
+      }
+      stopping = true;
+      try {
+        await stop();
+      } finally {
+        resolve();
+        process.exit(0);
+      }
+    };
+    process.on("SIGINT", () => void onSignal());
+    process.on("SIGTERM", () => void onSignal());
+    process.on("SIGQUIT", () => void onSignal());
+  }
 }

package/src/commands/devCommandLifecycle.types.ts

@@ -1,18 +1,18 @@
 import type { ChildProcess } from "node:child_process";
 
 import type { DevResolvedAuthSettings } from "../dev/DevAuthSettingsLoader";
-import type { ResolvedRuntimeToolEntrypoint } from "../dev/RuntimeToolEntrypointResolver";
+import type { DevApiRuntimeServerHandle } from "../dev/DevApiRuntimeFactory";
 import type { CliPaths } from "../path/CliPathResolver";
 
-export type DevMode = "consumer" | "framework";
+export type DevMode = "packaged-ui" | "watch-framework";
 
 /** Mutable child process handles and stop coordination (shared across dev session helpers). */
 export type DevMutableProcessState = {
-  currentGateway: ChildProcess | null;
-  currentNextHost: ChildProcess | null;
-  currentUiNext: ChildProcess | null;
-  currentUiProxyBaseUrl: string | null;
-  isRestartingNextHost: boolean;
+  currentDevUi: ChildProcess | null;
+  currentPackagedUi: ChildProcess | null;
+  currentPackagedUiBaseUrl: string | null;
+  currentRuntime: DevApiRuntimeServerHandle | null;
+  isRestartingUi: boolean;
   stopRequested: boolean;
   stopResolve: (() => void) | null;
   stopReject: ((error: Error) => void) | null;
@@ -26,9 +26,5 @@ export type DevPreparedRuntime = Readonly<{
   gatewayPort: number;
   authSettings: DevResolvedAuthSettings;
   developmentServerToken: string;
-  gatewayEntrypoint: ResolvedRuntimeToolEntrypoint;
-  runtimeEntrypoint: ResolvedRuntimeToolEntrypoint;
-  runtimeWorkingDirectory: string;
-  discoveredPluginPackagesJson: string;
   consumerEnv: Readonly<Record<string, string>>;
 }>;

package/src/database/ConsumerDatabaseConnectionResolver.ts

@@ -1,18 +1,64 @@
 import type { CodemationConfig } from "@codemation/host";
-import { DatabasePersistenceResolver } from "@codemation/host/persistence";
-import type { ResolvedDatabasePersistence } from "@codemation/host/persistence";
+import type { AppPersistenceConfig } from "@codemation/host/persistence";
+import path from "node:path";
 
 /**
  * Resolves TCP PostgreSQL vs PGlite vs none from env + {@link CodemationConfig} (same rules as the host runtime).
  */
 export class ConsumerDatabaseConnectionResolver {
-  private readonly resolver = new DatabasePersistenceResolver();
+  resolve(processEnv: NodeJS.ProcessEnv, config: CodemationConfig, consumerRoot: string): AppPersistenceConfig {
+    const database = config.runtime?.database;
+    if (!database) {
+      return { kind: "none" };
+    }
+    const databaseKind = this.resolveDatabaseKind(database.kind, database.url, processEnv);
+    if (databaseKind === "postgresql") {
+      const databaseUrl = database.url?.trim() ?? "";
+      if (!databaseUrl) {
+        throw new Error('runtime.database.kind is "postgresql" but no database URL was set (runtime.database.url).');
+      }
+      return { kind: "postgresql", databaseUrl };
+    }
+    return {
+      kind: "pglite",
+      dataDir: this.resolvePgliteDataDir(database.pgliteDataDir, processEnv, consumerRoot),
+    };
+  }
+
+  private resolveDatabaseKind(
+    configuredKind: "postgresql" | "pglite" | undefined,
+    databaseUrl: string | undefined,
+    env: NodeJS.ProcessEnv,
+  ): "postgresql" | "pglite" {
+    const kindFromEnv = env.CODEMATION_DATABASE_KIND?.trim();
+    if (kindFromEnv === "postgresql" || kindFromEnv === "pglite") {
+      return kindFromEnv;
+    }
+    if (configuredKind) {
+      return configuredKind;
+    }
+    const trimmedUrl = databaseUrl?.trim();
+    if (trimmedUrl && (trimmedUrl.startsWith("postgresql://") || trimmedUrl.startsWith("postgres://"))) {
+      return "postgresql";
+    }
+    return "pglite";
+  }
 
-  resolve(processEnv: NodeJS.ProcessEnv, config: CodemationConfig, consumerRoot: string): ResolvedDatabasePersistence {
-    return this.resolver.resolve({
-      runtimeConfig: config.runtime ?? {},
-      env: processEnv,
-      consumerRoot,
-    });
+  private resolvePgliteDataDir(
+    configuredPath: string | undefined,
+    env: NodeJS.ProcessEnv,
+    consumerRoot: string,
+  ): string {
+    const envPath = env.CODEMATION_PGLITE_DATA_DIR?.trim();
+    if (envPath && envPath.length > 0) {
+      return path.isAbsolute(envPath) ? envPath : path.resolve(consumerRoot, envPath);
+    }
+    const trimmedConfiguredPath = configuredPath?.trim();
+    if (trimmedConfiguredPath && trimmedConfiguredPath.length > 0) {
+      return path.isAbsolute(trimmedConfiguredPath)
+        ? trimmedConfiguredPath
+        : path.resolve(consumerRoot, trimmedConfiguredPath);
+    }
+    return path.resolve(consumerRoot, ".codemation", "pglite");
   }
 }

package/src/database/DatabaseMigrationsApplyService.ts

@@ -1,5 +1,5 @@
 import { CodemationConsumerConfigLoader } from "@codemation/host/server";
-import type { ResolvedDatabasePersistence } from "@codemation/host/persistence";
+import type { AppPersistenceConfig } from "@codemation/host/persistence";
 import type { Logger } from "@codemation/host/next/server";
 import path from "node:path";
 
@@ -9,7 +9,7 @@ import type { CliDatabaseUrlDescriptor } from "../user/CliDatabaseUrlDescriptor"
 import type { UserAdminConsumerDotenvLoader } from "../user/UserAdminConsumerDotenvLoader";
 
 export type DatabaseMigrationDeployer = {
-  deployPersistence(persistence: ResolvedDatabasePersistence, env?: Readonly<NodeJS.ProcessEnv>): Promise<void>;
+  deployPersistence(persistence: AppPersistenceConfig, env?: Readonly<NodeJS.ProcessEnv>): Promise<void>;
 };
 
 /**

package/src/dev/Builder.ts

@@ -1,47 +1,34 @@
 import { CodemationConsumerConfigLoader } from "@codemation/host/server";
-import type { ServerLoggerFactory } from "@codemation/host/next/server";
 
 import { ConsumerEnvLoader } from "../consumer/ConsumerEnvLoader";
 import { ListenPortResolver } from "../runtime/ListenPortResolver";
 import { SourceMapNodeOptions } from "../runtime/SourceMapNodeOptions";
 
-import { DevelopmentGatewayNotifier } from "./DevelopmentGatewayNotifier";
 import { DevAuthSettingsLoader } from "./DevAuthSettingsLoader";
 import { DevHttpProbe } from "./DevHttpProbe";
 import { DevNextHostEnvironmentBuilder } from "./DevNextHostEnvironmentBuilder";
 import { DevSessionPortsResolver } from "./DevSessionPortsResolver";
 import { DevSessionServices } from "./DevSessionServices";
 import { DevSourceChangeClassifier } from "./DevSourceChangeClassifier";
-import { DevSourceRestartCoordinator } from "./DevSourceRestartCoordinator";
 import { LoopbackPortAllocator } from "./LoopbackPortAllocator";
-import { RuntimeToolEntrypointResolver } from "./RuntimeToolEntrypointResolver";
 import { WatchRootsResolver } from "./WatchRootsResolver";
 
 export class DevSessionServicesBuilder {
-  constructor(private readonly loggerFactory: ServerLoggerFactory) {}
-
   build(): DevSessionServices {
     const consumerEnvLoader = new ConsumerEnvLoader();
     const sourceMapNodeOptions = new SourceMapNodeOptions();
     const listenPortResolver = new ListenPortResolver();
     const loopbackPortAllocator = new LoopbackPortAllocator();
-    const cliLogger = this.loggerFactory.create("codemation-cli");
     return new DevSessionServices(
       consumerEnvLoader,
       sourceMapNodeOptions,
       new DevSessionPortsResolver(listenPortResolver, loopbackPortAllocator),
       loopbackPortAllocator,
       new DevHttpProbe(),
-      new RuntimeToolEntrypointResolver(),
-      new DevAuthSettingsLoader(new CodemationConsumerConfigLoader()),
+      new DevAuthSettingsLoader(new CodemationConsumerConfigLoader(), consumerEnvLoader),
       new DevNextHostEnvironmentBuilder(consumerEnvLoader, sourceMapNodeOptions),
       new WatchRootsResolver(),
       new DevSourceChangeClassifier(),
-      new DevSourceRestartCoordinator(
-        new DevelopmentGatewayNotifier(cliLogger),
-        this.loggerFactory.createPerformanceDiagnostics("codemation-cli.performance"),
-        cliLogger,
-      ),
     );
   }
 }