@codemation/cli 0.0.15 → 0.0.18

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-BYHuUedo.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.15",
+  "version": "0.0.18",
   "publishConfig": {
     "access": "public"
   },
@@ -11,6 +11,7 @@
     "url": "https://github.com/MadeRelevant/codemation",
     "directory": "packages/cli"
   },
+  "license": "SEE LICENSE IN LICENSE",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -37,8 +38,8 @@
     "reflect-metadata": "^0.2.2",
     "typescript": "^5.9.3",
     "ws": "^8.19.0",
-    "@codemation/host": "0.0.15",
-    "@codemation/next-host": "0.0.15"
+    "@codemation/host": "0.0.18",
+    "@codemation/next-host": "0.0.18"
   },
   "devDependencies": {
     "@types/http-proxy": "^1.17.15",
@@ -49,7 +50,7 @@
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
     "vitest": "4.0.18",
-    "@codemation/eslint-config": "0.0.0"
+    "@codemation/eslint-config": "0.0.1"
   },
   "peerDependencies": {
     "tsx": ">=4.0.0"

package/src/CliProgramFactory.ts

@@ -1,36 +1,31 @@
-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 { ConsumerBuildArtifactsPublisher } from "./build/ConsumerBuildArtifactsPublisher";
 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 +54,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 +79,48 @@ export class CliProgramFactory {
     );
 
     const buildOptionsParser = new ConsumerBuildOptionsParser();
-    const devConsumerPublishBootstrap = new DevConsumerPublishBootstrap(
+    const consumerOutputBuilderFactory = new ConsumerOutputBuilderFactory();
+    const consumerBuildArtifactsPublisher = new ConsumerBuildArtifactsPublisher();
+    const devCommand = new DevCommand(
+      pathResolver,
+      tsRuntime,
+      new DevLockFactory(),
+      new DevSourceWatcherFactory(),
       cliLogger,
+      devSessionServices,
+      databaseMigrationsApplyService,
+      consumerOutputBuilderFactory,
       pluginDiscovery,
-      artifactsPublisher,
-      outputBuilderLoader,
-      buildOptionsParser,
+      consumerBuildArtifactsPublisher,
+      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(
+      new BuildCommand(
+        cliLogger,
         pathResolver,
+        consumerOutputBuilderFactory,
+        pluginDiscovery,
+        consumerBuildArtifactsPublisher,
         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(),
       ),
+      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/build/ConsumerBuildArtifactsPublisher.ts

@@ -32,14 +32,12 @@ export class ConsumerBuildArtifactsPublisher {
     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`;
+      const pluginModulePath = path.resolve(discoveredPlugin.packageRoot, this.resolvePluginEntry(discoveredPlugin));
+      const pluginFileUrl = pathToFileURL(pluginModulePath).href;
       outputLines.push(`const pluginModule${index} = await import(${JSON.stringify(pluginFileUrl)});`);
-      outputLines.push(`const pluginValue${index} = ${exportNameAccessor};`);
+      outputLines.push(
+        `const pluginValue${index} = pluginModule${index}.default ?? pluginModule${index}.codemationPlugin;`,
+      );
       outputLines.push(`if (pluginValue${index} && typeof pluginValue${index}.register === "function") {`);
       outputLines.push(`  codemationDiscoveredPlugins.push(pluginValue${index});`);
       outputLines.push(
@@ -74,4 +72,11 @@ export class ConsumerBuildArtifactsPublisher {
     await rename(temporaryManifestPath, snapshot.manifestPath);
     return manifest;
   }
+
+  private resolvePluginEntry(discoveredPlugin: CodemationDiscoveredPluginPackage): string {
+    if (typeof discoveredPlugin.developmentEntry === "string" && discoveredPlugin.developmentEntry.trim().length > 0) {
+      return discoveredPlugin.developmentEntry;
+    }
+    return discoveredPlugin.pluginEntry;
+  }
 }

package/src/commands/BuildCommand.ts

@@ -1,9 +1,9 @@
+import type { CodemationPluginDiscovery } from "@codemation/host/server";
 import type { Logger } from "@codemation/host/next/server";
-import { CodemationPluginDiscovery } from "@codemation/host/server";
 
-import { ConsumerBuildArtifactsPublisher } from "../build/ConsumerBuildArtifactsPublisher";
+import type { 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 +11,21 @@ export class BuildCommand {
   constructor(
     private readonly cliLogger: Logger,
     private readonly pathResolver: CliPathResolver,
+    private readonly consumerOutputBuilderFactory: ConsumerOutputBuilderFactory,
     private readonly pluginDiscovery: CodemationPluginDiscovery,
-    private readonly artifactsPublisher: ConsumerBuildArtifactsPublisher,
+    private readonly consumerBuildArtifactsPublisher: 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 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);
+    const manifest = await this.consumerBuildArtifactsPublisher.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(`Build manifest: ${manifest.manifestPath}`);
+    this.cliLogger.info(`Workflow modules emitted: ${snapshot.workflowSourcePaths.length}`);
   }
 }

package/src/commands/DevCommand.ts

@@ -1,16 +1,18 @@
+import type { CodemationPluginDiscovery } from "@codemation/host/server";
 import type { Logger } from "@codemation/host/next/server";
 import { spawn, type ChildProcess } from "node:child_process";
 import { createRequire } from "node:module";
 import path from "node:path";
 import process from "node:process";
 
+import type { ConsumerBuildArtifactsPublisher } from "../build/ConsumerBuildArtifactsPublisher";
+import type { ConsumerOutputBuilderFactory } from "../consumer/ConsumerOutputBuilderFactory";
 import type { DatabaseMigrationsApplyService } from "../database/DatabaseMigrationsApplyService";
 import type { DevApiRuntimeFactory, DevApiRuntimeServerHandle } from "../dev/DevApiRuntimeFactory";
 import type { DevBootstrapSummaryFetcher } from "../dev/DevBootstrapSummaryFetcher";
 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 +20,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";
@@ -36,9 +38,11 @@ export class DevCommand {
     private readonly cliLogger: Logger,
     private readonly session: DevSessionServices,
     private readonly databaseMigrationsApplyService: DatabaseMigrationsApplyService,
+    private readonly consumerOutputBuilderFactory: ConsumerOutputBuilderFactory,
+    private readonly pluginDiscovery: CodemationPluginDiscovery,
+    private readonly consumerBuildArtifactsPublisher: ConsumerBuildArtifactsPublisher,
     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 +51,22 @@ 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";
+    const previousDevelopmentServerToken = process.env.CODEMATION_DEV_SERVER_TOKEN;
     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 +78,29 @@ 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,
+      );
+      if (prepared.devMode === "packaged-ui") {
+        await this.publishConsumerArtifacts(prepared.paths, prepared.configPathOverride);
+      }
+      // The disposable runtime is created in-process, so config reloads must see the same token in
+      // `process.env` that we also pass through the child-facing env object.
+      process.env.CODEMATION_DEV_SERVER_TOKEN = prepared.developmentServerToken;
       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,12 +109,21 @@ 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 {
+      if (previousDevelopmentServerToken === undefined) {
+        delete process.env.CODEMATION_DEV_SERVER_TOKEN;
+      } else {
+        process.env.CODEMATION_DEV_SERVER_TOKEN = previousDevelopmentServerToken;
+      }
       processState.stopRequested = true;
       await this.stopLiveProcesses(processState, proxyServer);
       await watcher.stop();
@@ -105,14 +143,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 +186,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 +324,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 +374,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 +398,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 +426,7 @@ export class DevCommand {
     proxyServer: CliDevProxyServer,
     request: Readonly<{
       changedPaths: ReadonlyArray<string>;
-      shouldRepublishConsumerOutput: boolean;
+      configPathOverride?: string;
       shouldRestartUi: boolean;
     }>,
   ): Promise<void> {
@@ -391,8 +434,8 @@ export class DevCommand {
     proxyServer.setBuildStatus("building");
     proxyServer.broadcastBuildStarted();
     try {
-      if (request.shouldRepublishConsumerOutput) {
-        await this.devConsumerPublishBootstrap.ensurePublished(prepared.paths);
+      if (prepared.devMode === "packaged-ui") {
+        await this.publishConsumerArtifacts(prepared.paths, request.configPathOverride);
       }
       await this.stopCurrentRuntime(state, proxyServer);
       process.stdout.write("[codemation] Waiting for runtime to accept traffic…\n");
@@ -402,15 +445,18 @@ export class DevCommand {
         httpPort: runtime.httpPort,
         workflowWebSocketPort: runtime.workflowWebSocketPort,
       });
-      if (request.shouldRestartUi) {
-        await this.restartUiAfterSourceChange(prepared, state, gatewayBaseUrl);
-      }
       await this.session.devHttpProbe.waitUntilBootstrapSummaryReady(gatewayBaseUrl);
       const json = await this.devBootstrapSummaryFetcher.fetch(gatewayBaseUrl);
       if (json) {
         this.devCliBannerRenderer.renderCompact(json);
       }
       proxyServer.setBuildStatus("idle");
+      // Let the new runtime become queryable through the stable gateway before restarting the
+      // packaged UI; otherwise the UI bootstrap hits `/api/bootstrap/*` while the gateway still
+      // reports "Runtime is rebuilding" and the restart can deadlock indefinitely.
+      if (request.shouldRestartUi) {
+        await this.restartUiAfterSourceChange(prepared, state, gatewayBaseUrl);
+      }
       proxyServer.broadcastBuildCompleted(runtime.buildVersion);
       process.stdout.write("[codemation] Runtime ready.\n");
     } catch (error) {
@@ -425,7 +471,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 +493,7 @@ export class DevCommand {
   private async restartPackagedUi(
     prepared: DevPreparedRuntime,
     state: DevMutableProcessState,
-    authSettings: DevResolvedAuthSettings,
+    authSettings: NextHostEdgeSeed,
   ): Promise<void> {
     if (
       state.currentPackagedUi &&
@@ -463,7 +514,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 +568,7 @@ export class DevCommand {
       prepared.consumerEnv,
     );
     return await this.devApiRuntimeFactory.create({
+      configPathOverride: prepared.configPathOverride,
       consumerRoot: prepared.paths.consumerRoot,
       runtimeWorkingDirectory: process.cwd(),
       env: {
@@ -530,12 +582,26 @@ export class DevCommand {
     });
   }
 
-  private logPackagedUiDevHintWhenNeeded(devMode: DevMode, gatewayPort: number): void {
+  private async publishConsumerArtifacts(paths: CliPaths, configPathOverride?: string): Promise<void> {
+    const builder = this.consumerOutputBuilderFactory.create(paths.consumerRoot, {
+      configPathOverride,
+    });
+    const snapshot = await builder.ensureBuilt();
+    const discoveredPlugins = await this.pluginDiscovery.discover(paths.consumerRoot);
+    await this.consumerBuildArtifactsPublisher.publish(snapshot, discoveredPlugins);
+    this.cliLogger.debug(`Dev: consumer output published (${snapshot.buildVersion}).`);
+  }
+
+  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.`,
     );
   }
 }