@codemation/cli 0.0.14 → 0.0.16

package/dist/index.js

@@ -1,4 +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-BkY_gChN.js";
+import { a as CliProgram, i as CliPathResolver, n as CliProgramFactory, o as ConsumerOutputBuilder, r as CodemationCliApplicationSession, s as ConsumerBuildOptionsParser, t as CliBin } from "./CliBin-C31h2o8w.js";
 import { CodemationPluginDiscovery } from "@codemation/host/server";
 
 export { CliBin, CliPathResolver, CliProgram, CliProgramFactory, CodemationCliApplicationSession, CodemationPluginDiscovery, ConsumerBuildOptionsParser, ConsumerOutputBuilder };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codemation/cli",
-  "version": "0.0.14",
+  "version": "0.0.16",
   "publishConfig": {
     "access": "public"
   },
@@ -37,8 +37,8 @@
     "reflect-metadata": "^0.2.2",
     "typescript": "^5.9.3",
     "ws": "^8.19.0",
-    "@codemation/next-host": "0.0.14",
-    "@codemation/host": "0.0.14"
+    "@codemation/host": "0.0.16",
+    "@codemation/next-host": "0.0.16"
   },
   "devDependencies": {
     "@types/http-proxy": "^1.17.15",

package/src/CliProgramFactory.ts

@@ -1,36 +1,30 @@
-import {
-  AppConfigLoader,
-  CodemationConsumerConfigLoader,
-  CodemationFrontendAuthSnapshotFactory,
-  CodemationPluginDiscovery,
-  FrontendAppConfigJsonCodec,
-} from "@codemation/host/server";
+import { AppConfigLoader, CodemationConsumerConfigLoader, CodemationPluginDiscovery } from "@codemation/host/server";
 import { AppContainerFactory } from "@codemation/host";
 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 { DevPluginCommand } from "./commands/DevPluginCommand";
 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 { ConsumerOutputBuilderFactory } from "./consumer/ConsumerOutputBuilderFactory";
 import { ConsumerDatabaseConnectionResolver } from "./database/ConsumerDatabaseConnectionResolver";
 import { DatabaseMigrationsApplyService } from "./database/DatabaseMigrationsApplyService";
 import { HostPackageRootResolver } from "./database/HostPackageRootResolver";
 import { PrismaMigrationDeployer } from "@codemation/host/persistence";
 import { DevBootstrapSummaryFetcher } from "./dev/DevBootstrapSummaryFetcher";
 import { DevCliBannerRenderer } from "./dev/DevCliBannerRenderer";
-import { DevConsumerPublishBootstrap } from "./dev/DevConsumerPublishBootstrap";
 import { CliDevProxyServerFactory } from "./dev/CliDevProxyServerFactory";
 import { DevApiRuntimeFactory } from "./dev/DevApiRuntimeFactory";
 import { DevRebuildQueueFactory } from "./dev/DevRebuildQueueFactory";
 import { DevSessionServicesBuilder } from "./dev/Builder";
+import { PluginDevConfigFactory } from "./dev/PluginDevConfigFactory";
 import { DevLockFactory } from "./dev/Factory";
 import { ConsumerEnvDotenvFilePredicate } from "./dev/ConsumerEnvDotenvFilePredicate";
 import { DevTrackedProcessTreeKiller } from "./dev/DevTrackedProcessTreeKiller";
@@ -59,9 +53,7 @@ export class CliProgramFactory {
     const appConfigLoader = new AppConfigLoader();
     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 nextHostConsumerServerCommandFactory = new NextHostConsumerServerCommandFactory();
     const devSessionServices = new DevSessionServicesBuilder().build();
@@ -86,47 +78,36 @@ export class CliProgramFactory {
     );
 
     const buildOptionsParser = new ConsumerBuildOptionsParser();
-    const devConsumerPublishBootstrap = new DevConsumerPublishBootstrap(
+    const devCommand = new DevCommand(
+      pathResolver,
+      tsRuntime,
+      new DevLockFactory(),
+      new DevSourceWatcherFactory(),
       cliLogger,
-      pluginDiscovery,
-      artifactsPublisher,
-      outputBuilderLoader,
-      buildOptionsParser,
+      devSessionServices,
+      databaseMigrationsApplyService,
+      new DevBootstrapSummaryFetcher(),
+      new DevCliBannerRenderer(),
+      new ConsumerEnvDotenvFilePredicate(),
+      new DevTrackedProcessTreeKiller(),
+      nextHostConsumerServerCommandFactory,
+      new DevApiRuntimeFactory(devSessionServices.loopbackPortAllocator, appConfigLoader, pluginDiscovery),
+      new CliDevProxyServerFactory(),
+      new DevRebuildQueueFactory(),
     );
     return new CliProgram(
       buildOptionsParser,
-      new BuildCommand(cliLogger, pathResolver, pluginDiscovery, artifactsPublisher, tsRuntime, outputBuilderLoader),
-      new DevCommand(
-        pathResolver,
-        tsRuntime,
-        new DevLockFactory(),
-        new DevSourceWatcherFactory(),
-        cliLogger,
-        devSessionServices,
-        databaseMigrationsApplyService,
-        new DevBootstrapSummaryFetcher(),
-        new DevCliBannerRenderer(),
-        devConsumerPublishBootstrap,
-        new ConsumerEnvDotenvFilePredicate(),
-        new DevTrackedProcessTreeKiller(),
-        nextHostConsumerServerCommandFactory,
-        new DevApiRuntimeFactory(devSessionServices.loopbackPortAllocator, appConfigLoader, pluginDiscovery),
-        new CliDevProxyServerFactory(),
-        new DevRebuildQueueFactory(),
-      ),
+      new BuildCommand(cliLogger, pathResolver, new ConsumerOutputBuilderFactory(), tsRuntime),
+      devCommand,
+      new DevPluginCommand(new PluginDevConfigFactory(), devCommand),
       new ServeWebCommand(
         pathResolver,
         new CodemationConsumerConfigLoader(),
-        pluginDiscovery,
-        artifactsPublisher,
         tsRuntime,
         sourceMapNodeOptions,
-        outputBuilderLoader,
         new ConsumerEnvLoader(),
         new ListenPortResolver(),
         nextHostConsumerServerCommandFactory,
-        new CodemationFrontendAuthSnapshotFactory(),
-        new FrontendAppConfigJsonCodec(),
       ),
       new ServeWorkerCommand(pathResolver, appConfigLoader, new AppContainerFactory()),
       new DbMigrateCommand(databaseMigrationsApplyService),

package/src/Program.ts

@@ -8,6 +8,7 @@ import { ConsumerBuildOptionsParser } from "./build/ConsumerBuildOptionsParser";
 import { BuildCommand } from "./commands/BuildCommand";
 import type { DbMigrateCommand } from "./commands/DbMigrateCommand";
 import { DevCommand } from "./commands/DevCommand";
+import type { DevPluginCommand } from "./commands/DevPluginCommand";
 import { ServeWebCommand } from "./commands/ServeWebCommand";
 import { ServeWorkerCommand } from "./commands/ServeWorkerCommand";
 import { UserCreateCommand } from "./commands/UserCreateCommand";
@@ -18,6 +19,7 @@ export class CliProgram {
     private readonly buildOptionsParser: ConsumerBuildOptionsParser,
     private readonly buildCommand: BuildCommand,
     private readonly devCommand: DevCommand,
+    private readonly devPluginCommand: DevPluginCommand,
     private readonly serveWebCommand: ServeWebCommand,
     private readonly serveWorkerCommand: ServeWorkerCommand,
     private readonly dbMigrateCommand: DbMigrateCommand,
@@ -68,6 +70,16 @@ export class CliProgram {
         });
       });
 
+    program
+      .command("dev:plugin")
+      .description("Start plugin sandbox development using `codemation.plugin.ts`.")
+      .option("--plugin-root <path>", "Path to the plugin project root (defaults to cwd)")
+      .action(async (opts: Readonly<{ pluginRoot?: string }>) => {
+        await this.devPluginCommand.execute({
+          pluginRoot: resolveConsumerRoot(opts.pluginRoot),
+        });
+      });
+
     const serve = program.command("serve").description("Run production web or worker processes (no dev watchers).");
 
     serve

package/src/commands/BuildCommand.ts

@@ -1,9 +1,7 @@
 import type { Logger } from "@codemation/host/next/server";
-import { CodemationPluginDiscovery } from "@codemation/host/server";
 
-import { ConsumerBuildArtifactsPublisher } from "../build/ConsumerBuildArtifactsPublisher";
+import type { ConsumerOutputBuilderFactory } from "../consumer/ConsumerOutputBuilderFactory";
 import type { ConsumerBuildOptions } from "../consumer/consumerBuildOptions.types";
-import { ConsumerOutputBuilderLoader } from "../consumer/Loader";
 import { CliPathResolver } from "../path/CliPathResolver";
 import { TypeScriptRuntimeConfigurator } from "../runtime/TypeScriptRuntimeConfigurator";
 
@@ -11,21 +9,16 @@ export class BuildCommand {
   constructor(
     private readonly cliLogger: Logger,
     private readonly pathResolver: CliPathResolver,
-    private readonly pluginDiscovery: CodemationPluginDiscovery,
-    private readonly artifactsPublisher: ConsumerBuildArtifactsPublisher,
+    private readonly consumerOutputBuilderFactory: ConsumerOutputBuilderFactory,
     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 builder = this.consumerOutputBuilderFactory.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}`);
+    this.cliLogger.info(`Workflow modules emitted: ${snapshot.workflowSourcePaths.length}`);
   }
 }

package/src/commands/DevCommand.ts

@@ -10,7 +10,6 @@ import type { DevBootstrapSummaryFetcher } from "../dev/DevBootstrapSummaryFetch
 import type { CliDevProxyServer } from "../dev/CliDevProxyServer";
 import type { CliDevProxyServerFactory } from "../dev/CliDevProxyServerFactory";
 import type { DevCliBannerRenderer } from "../dev/DevCliBannerRenderer";
-import type { DevConsumerPublishBootstrap } from "../dev/DevConsumerPublishBootstrap";
 import { ConsumerEnvDotenvFilePredicate } from "../dev/ConsumerEnvDotenvFilePredicate";
 import type { DevRebuildQueueFactory } from "../dev/DevRebuildQueueFactory";
 import type { DevSourceWatcher } from "../dev/DevSourceWatcher";
@@ -18,7 +17,7 @@ import { DevSessionServices } from "../dev/DevSessionServices";
 import { DevLockFactory } from "../dev/Factory";
 import { DevTrackedProcessTreeKiller } from "../dev/DevTrackedProcessTreeKiller";
 import { DevSourceWatcherFactory } from "../dev/Runner";
-import type { DevResolvedAuthSettings } from "../dev/DevAuthSettingsLoader";
+import type { NextHostEdgeSeed } from "../dev/NextHostEdgeSeedLoader";
 import { CliPathResolver, type CliPaths } from "../path/CliPathResolver";
 import { NextHostConsumerServerCommandFactory } from "../runtime/NextHostConsumerServerCommandFactory";
 import { TypeScriptRuntimeConfigurator } from "../runtime/TypeScriptRuntimeConfigurator";
@@ -38,7 +37,6 @@ export class DevCommand {
     private readonly databaseMigrationsApplyService: DatabaseMigrationsApplyService,
     private readonly devBootstrapSummaryFetcher: DevBootstrapSummaryFetcher,
     private readonly devCliBannerRenderer: DevCliBannerRenderer,
-    private readonly devConsumerPublishBootstrap: DevConsumerPublishBootstrap,
     private readonly consumerEnvDotenvFilePredicate: ConsumerEnvDotenvFilePredicate,
     private readonly devTrackedProcessTreeKiller: DevTrackedProcessTreeKiller,
     private readonly nextHostConsumerServerCommandFactory: NextHostConsumerServerCommandFactory,
@@ -47,12 +45,21 @@ export class DevCommand {
     private readonly devRebuildQueueFactory: DevRebuildQueueFactory,
   ) {}
 
-  async execute(args: Readonly<{ consumerRoot: string; watchFramework?: boolean }>): Promise<void> {
+  async execute(
+    args: Readonly<{
+      consumerRoot: string;
+      watchFramework?: boolean;
+      commandName?: "dev" | "dev:plugin";
+      configPathOverride?: string;
+    }>,
+  ): Promise<void> {
     const paths = await this.pathResolver.resolve(args.consumerRoot);
+    const commandName = args.commandName ?? "dev";
     this.devCliBannerRenderer.renderBrandHeader();
     this.tsRuntime.configure(paths.repoRoot);
-    await this.databaseMigrationsApplyService.applyForConsumer(paths.consumerRoot);
-    await this.devConsumerPublishBootstrap.ensurePublished(paths);
+    await this.databaseMigrationsApplyService.applyForConsumer(paths.consumerRoot, {
+      configPath: args.configPathOverride,
+    });
     const devMode = this.resolveDevMode(args);
     const { nextPort, gatewayPort } = await this.session.sessionPorts.resolve({
       devMode,
@@ -64,14 +71,23 @@ export class DevCommand {
       consumerRoot: paths.consumerRoot,
       nextPort: devMode === "watch-framework" ? nextPort : gatewayPort,
     });
-    const authSettings = await this.session.devAuthLoader.loadForConsumer(paths.consumerRoot);
+    const authSettings = await this.session.nextHostEdgeSeedLoader.loadForConsumer(paths.consumerRoot, {
+      configPathOverride: args.configPathOverride,
+    });
     const watcher = this.devSourceWatcherFactory.create();
     const processState = this.createInitialProcessState();
     let proxyServer: CliDevProxyServer | null = null;
     try {
-      const prepared = await this.prepareDevRuntime(paths, devMode, nextPort, gatewayPort, authSettings);
+      const prepared = await this.prepareDevRuntime(
+        paths,
+        devMode,
+        nextPort,
+        gatewayPort,
+        authSettings,
+        args.configPathOverride,
+      );
       const stopPromise = this.wireStopPromise(processState);
-      const uiProxyBase = await this.startPackagedUiWhenNeeded(prepared, processState);
+      const uiProxyBase = await this.preparePackagedUiBaseUrlWhenNeeded(prepared, processState);
       proxyServer = await this.startProxyServer(prepared.gatewayPort, uiProxyBase);
       const gatewayBaseUrl = this.gatewayBaseHttpUrl(gatewayPort);
       await this.bootInitialRuntime(prepared, processState, proxyServer);
@@ -80,10 +96,14 @@ export class DevCommand {
       if (initialSummary) {
         this.devCliBannerRenderer.renderRuntimeSummary(initialSummary);
       }
+      await this.startPackagedUiWhenNeeded(prepared, processState, uiProxyBase);
       this.bindShutdownSignalsToChildProcesses(processState, proxyServer);
       await this.spawnDevUiWhenNeeded(prepared, processState, gatewayBaseUrl);
-      await this.startWatcherForSourceRestart(prepared, processState, watcher, devMode, gatewayBaseUrl, proxyServer);
-      this.logPackagedUiDevHintWhenNeeded(devMode, gatewayPort);
+      await this.startWatcherForSourceRestart(prepared, processState, watcher, devMode, gatewayBaseUrl, proxyServer, {
+        commandName,
+        configPathOverride: args.configPathOverride,
+      });
+      this.logPackagedUiDevHintWhenNeeded(devMode, gatewayPort, commandName);
       await stopPromise;
     } finally {
       processState.stopRequested = true;
@@ -105,14 +125,16 @@ export class DevCommand {
     devMode: DevMode,
     nextPort: number,
     gatewayPort: number,
-    authSettings: DevResolvedAuthSettings,
+    authSettings: NextHostEdgeSeed,
+    configPathOverride?: string,
   ): Promise<DevPreparedRuntime> {
-    const developmentServerToken = this.session.devAuthLoader.resolveDevelopmentServerToken(
+    const developmentServerToken = this.session.nextHostEdgeSeedLoader.resolveDevelopmentServerToken(
       process.env.CODEMATION_DEV_SERVER_TOKEN,
     );
     const consumerEnv = this.session.consumerEnvLoader.load(paths.consumerRoot);
     return {
       paths,
+      configPathOverride,
       devMode,
       nextPort,
       gatewayPort,
@@ -146,48 +168,50 @@ export class DevCommand {
     return `http://127.0.0.1:${gatewayPort}`;
   }
 
-  private async startPackagedUiWhenNeeded(
+  private async preparePackagedUiBaseUrlWhenNeeded(
     prepared: DevPreparedRuntime,
     state: DevMutableProcessState,
   ): Promise<string> {
     if (prepared.devMode !== "packaged-ui") {
       return "";
     }
-    const websocketPort = prepared.gatewayPort;
     const uiProxyBase =
       state.currentPackagedUiBaseUrl ?? `http://127.0.0.1:${await this.session.loopbackPortAllocator.allocate()}`;
     state.currentPackagedUiBaseUrl = uiProxyBase;
-    await this.spawnPackagedUi(prepared, state, prepared.authSettings, websocketPort, uiProxyBase);
     return uiProxyBase;
   }
 
+  private async startPackagedUiWhenNeeded(
+    prepared: DevPreparedRuntime,
+    state: DevMutableProcessState,
+    uiProxyBase: string,
+  ): Promise<void> {
+    if (prepared.devMode !== "packaged-ui" || uiProxyBase.length === 0) {
+      return;
+    }
+    await this.spawnPackagedUi(prepared, state, prepared.authSettings, prepared.gatewayPort, uiProxyBase);
+  }
+
   private async spawnPackagedUi(
     prepared: DevPreparedRuntime,
     state: DevMutableProcessState,
-    authSettings: DevResolvedAuthSettings,
+    authSettings: NextHostEdgeSeed,
     websocketPort: number,
     uiProxyBase: string,
   ): Promise<void> {
     const nextHostPackageJsonPath = this.require.resolve("@codemation/next-host/package.json");
     const nextHostRoot = path.dirname(nextHostPackageJsonPath);
     const nextHostCommand = await this.nextHostConsumerServerCommandFactory.create({ nextHostRoot });
-    const consumerOutputManifestPath = path.resolve(
-      prepared.paths.consumerRoot,
-      ".codemation",
-      "output",
-      "current.json",
-    );
     const uiPort = Number(new URL(uiProxyBase).port);
     const nextHostEnvironment = this.session.nextHostEnvBuilder.buildConsumerUiProxy({
-      authConfigJson: authSettings.authConfigJson,
       authSecret: authSettings.authSecret,
+      configPathOverride: prepared.configPathOverride,
       consumerRoot: prepared.paths.consumerRoot,
-      consumerOutputManifestPath,
       developmentServerToken: prepared.developmentServerToken,
       nextPort: uiPort,
       publicBaseUrl: this.gatewayBaseHttpUrl(prepared.gatewayPort),
       runtimeDevUrl: this.gatewayBaseHttpUrl(prepared.gatewayPort),
-      skipUiAuth: authSettings.skipUiAuth,
+      skipUiAuth: !authSettings.uiAuthEnabled,
       websocketPort,
     });
     state.currentPackagedUi = spawn(nextHostCommand.command, nextHostCommand.args, {
@@ -282,17 +306,18 @@ export class DevCommand {
     prepared: DevPreparedRuntime,
     state: DevMutableProcessState,
     gatewayBaseUrl: string,
-    authSettings: DevResolvedAuthSettings,
+    authSettings: NextHostEdgeSeed,
   ): Promise<void> {
     const websocketPort = prepared.gatewayPort;
     const nextHostPackageJsonPath = this.require.resolve("@codemation/next-host/package.json");
     const nextHostRoot = path.dirname(nextHostPackageJsonPath);
     const nextHostEnvironment = this.session.nextHostEnvBuilder.build({
-      authConfigJson: authSettings.authConfigJson,
+      authSecret: authSettings.authSecret,
+      configPathOverride: prepared.configPathOverride,
       consumerRoot: prepared.paths.consumerRoot,
       developmentServerToken: prepared.developmentServerToken,
       nextPort: prepared.nextPort,
-      skipUiAuth: authSettings.skipUiAuth,
+      skipUiAuth: !authSettings.uiAuthEnabled,
       websocketPort,
       runtimeDevUrl: gatewayBaseUrl,
     });
@@ -331,6 +356,10 @@ export class DevCommand {
     devMode: DevMode,
     gatewayBaseUrl: string,
     proxyServer: CliDevProxyServer,
+    options: Readonly<{
+      commandName: "dev" | "dev:plugin";
+      configPathOverride?: string;
+    }>,
   ): Promise<void> {
     const rebuildQueue = this.devRebuildQueueFactory.create({
       run: async (request) => {
@@ -351,22 +380,18 @@ export class DevCommand {
           return;
         }
         try {
-          const shouldRepublishConsumerOutput = this.session.sourceChangeClassifier.shouldRepublishConsumerOutput({
-            changedPaths,
-            consumerRoot: prepared.paths.consumerRoot,
-          });
           const shouldRestartUi = this.session.sourceChangeClassifier.requiresUiRestart({
             changedPaths,
             consumerRoot: prepared.paths.consumerRoot,
           });
           process.stdout.write(
             shouldRestartUi
-              ? "\n[codemation] Source change detected — rebuilding consumer, restarting the runtime, and restarting the UI…\n"
-              : "\n[codemation] Source change detected — rebuilding consumer and restarting the runtime…\n",
+              ? `\n[codemation] Source change detected — rebuilding for \`${options.commandName}\`, restarting the runtime, and restarting the UI…\n`
+              : `\n[codemation] Source change detected — rebuilding for \`${options.commandName}\` and restarting the runtime…\n`,
           );
           await rebuildQueue.enqueue({
             changedPaths,
-            shouldRepublishConsumerOutput,
+            configPathOverride: options.configPathOverride,
             shouldRestartUi,
           });
         } catch (error) {
@@ -383,7 +408,7 @@ export class DevCommand {
     proxyServer: CliDevProxyServer,
     request: Readonly<{
       changedPaths: ReadonlyArray<string>;
-      shouldRepublishConsumerOutput: boolean;
+      configPathOverride?: string;
       shouldRestartUi: boolean;
     }>,
   ): Promise<void> {
@@ -391,9 +416,6 @@ export class DevCommand {
     proxyServer.setBuildStatus("building");
     proxyServer.broadcastBuildStarted();
     try {
-      if (request.shouldRepublishConsumerOutput) {
-        await this.devConsumerPublishBootstrap.ensurePublished(prepared.paths);
-      }
       await this.stopCurrentRuntime(state, proxyServer);
       process.stdout.write("[codemation] Waiting for runtime to accept traffic…\n");
       const runtime = await this.createRuntime(prepared);
@@ -425,7 +447,12 @@ export class DevCommand {
     state: DevMutableProcessState,
     gatewayBaseUrl: string,
   ): Promise<void> {
-    const refreshedAuthSettings = await this.session.devAuthLoader.loadForConsumer(prepared.paths.consumerRoot);
+    const refreshedAuthSettings = await this.session.nextHostEdgeSeedLoader.loadForConsumer(
+      prepared.paths.consumerRoot,
+      {
+        configPathOverride: prepared.configPathOverride,
+      },
+    );
     process.stdout.write("[codemation] Restarting the UI process to apply source changes…\n");
     state.isRestartingUi = true;
     try {
@@ -442,7 +469,7 @@ export class DevCommand {
   private async restartPackagedUi(
     prepared: DevPreparedRuntime,
     state: DevMutableProcessState,
-    authSettings: DevResolvedAuthSettings,
+    authSettings: NextHostEdgeSeed,
   ): Promise<void> {
     if (
       state.currentPackagedUi &&
@@ -463,7 +490,7 @@ export class DevCommand {
     prepared: DevPreparedRuntime,
     state: DevMutableProcessState,
     gatewayBaseUrl: string,
-    authSettings: DevResolvedAuthSettings,
+    authSettings: NextHostEdgeSeed,
   ): Promise<void> {
     if (state.currentDevUi && state.currentDevUi.exitCode === null && state.currentDevUi.signalCode === null) {
       await this.devTrackedProcessTreeKiller.killProcessTreeRootedAt(state.currentDevUi);
@@ -517,6 +544,7 @@ export class DevCommand {
       prepared.consumerEnv,
     );
     return await this.devApiRuntimeFactory.create({
+      configPathOverride: prepared.configPathOverride,
       consumerRoot: prepared.paths.consumerRoot,
       runtimeWorkingDirectory: process.cwd(),
       env: {
@@ -530,12 +558,16 @@ export class DevCommand {
     });
   }
 
-  private logPackagedUiDevHintWhenNeeded(devMode: DevMode, gatewayPort: number): void {
+  private logPackagedUiDevHintWhenNeeded(
+    devMode: DevMode,
+    gatewayPort: number,
+    commandName: "dev" | "dev:plugin",
+  ): void {
     if (devMode !== "packaged-ui") {
       return;
     }
     this.cliLogger.info(
-      `codemation dev: open http://127.0.0.1:${gatewayPort} — this uses the packaged @codemation/next-host UI. Use \`codemation dev --watch-framework\` only when working on the framework UI itself.`,
+      `codemation ${commandName}: open http://127.0.0.1:${gatewayPort} — this uses the packaged @codemation/next-host UI. Use \`codemation ${commandName} --watch-framework\` only when working on the framework UI itself.`,
     );
   }
 }

package/src/commands/DevPluginCommand.ts

@@ -0,0 +1,19 @@
+import type { DevCommand } from "./DevCommand";
+import type { PluginDevConfigFactory } from "../dev/PluginDevConfigFactory";
+
+export class DevPluginCommand {
+  constructor(
+    private readonly pluginDevConfigFactory: PluginDevConfigFactory,
+    private readonly devCommand: DevCommand,
+  ) {}
+
+  async execute(args: Readonly<{ pluginRoot: string; watchFramework?: boolean }>): Promise<void> {
+    const pluginConfig = await this.pluginDevConfigFactory.prepare(args.pluginRoot);
+    await this.devCommand.execute({
+      commandName: "dev:plugin",
+      configPathOverride: pluginConfig.configPath,
+      consumerRoot: args.pluginRoot,
+      watchFramework: args.watchFramework,
+    });
+  }
+}

package/src/commands/ServeWebCommand.ts

@@ -1,18 +1,11 @@
-import {
-  CodemationConsumerConfigLoader,
-  CodemationFrontendAuthSnapshotFactory,
-  CodemationPluginDiscovery,
-  FrontendAppConfigJsonCodec,
-} from "@codemation/host/server";
+import { CodemationConsumerConfigLoader } from "@codemation/host/server";
 import { spawn } from "node:child_process";
 import { createRequire } from "node:module";
 import path from "node:path";
 import process from "node:process";
 
-import { ConsumerBuildArtifactsPublisher } from "../build/ConsumerBuildArtifactsPublisher";
 import { ConsumerEnvLoader } from "../consumer/ConsumerEnvLoader";
 import type { ConsumerBuildOptions } from "../consumer/consumerBuildOptions.types";
-import { ConsumerOutputBuilderLoader } from "../consumer/Loader";
 import { CliPathResolver } from "../path/CliPathResolver";
 import { ListenPortResolver } from "../runtime/ListenPortResolver";
 import { NextHostConsumerServerCommandFactory } from "../runtime/NextHostConsumerServerCommandFactory";
@@ -25,40 +18,21 @@ export class ServeWebCommand {
   constructor(
     private readonly pathResolver: CliPathResolver,
     private readonly configLoader: CodemationConsumerConfigLoader,
-    private readonly pluginDiscovery: CodemationPluginDiscovery,
-    private readonly artifactsPublisher: ConsumerBuildArtifactsPublisher,
     private readonly tsRuntime: TypeScriptRuntimeConfigurator,
     private readonly sourceMapNodeOptions: SourceMapNodeOptions,
-    private readonly outputBuilderLoader: ConsumerOutputBuilderLoader,
     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> {
+    void buildOptions;
     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);
     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,
@@ -72,13 +46,13 @@ 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_UI_AUTH_ENABLED: String(
+          !(
+            consumerEnv.NODE_ENV !== "production" &&
+            configResolution.config.auth?.allowUnauthenticatedInDevelopment === true
+          ),
+        ),
         CODEMATION_WS_PORT: String(websocketPort),
         NEXT_PUBLIC_CODEMATION_WS_PORT: String(websocketPort),
         NODE_OPTIONS: this.sourceMapNodeOptions.appendToNodeOptions(process.env.NODE_OPTIONS),

package/src/commands/devCommandLifecycle.types.ts

@@ -1,7 +1,7 @@
 import type { ChildProcess } from "node:child_process";
 
-import type { DevResolvedAuthSettings } from "../dev/DevAuthSettingsLoader";
 import type { DevApiRuntimeServerHandle } from "../dev/DevApiRuntimeFactory";
+import type { NextHostEdgeSeed } from "../dev/NextHostEdgeSeedLoader";
 import type { CliPaths } from "../path/CliPathResolver";
 
 export type DevMode = "packaged-ui" | "watch-framework";
@@ -21,10 +21,11 @@ export type DevMutableProcessState = {
 /** Immutable inputs resolved before any child processes are spawned. */
 export type DevPreparedRuntime = Readonly<{
   paths: CliPaths;
+  configPathOverride?: string;
   devMode: DevMode;
   nextPort: number;
   gatewayPort: number;
-  authSettings: DevResolvedAuthSettings;
+  authSettings: NextHostEdgeSeed;
   developmentServerToken: string;
   consumerEnv: Readonly<Record<string, string>>;
 }>;