@codemation/cli 0.0.15 → 0.0.18

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>>;
 }>;

package/src/consumer/ConsumerOutputBuilder.ts

@@ -63,6 +63,7 @@ export class ConsumerOutputBuilder {
     private readonly consumerRoot: string,
     logOverride?: Logger,
     buildOptionsOverride?: ConsumerBuildOptions,
+    private readonly configPathOverride?: string,
   ) {
     this.log = logOverride ?? defaultConsumerOutputLogger;
     this.buildOptions = buildOptionsOverride ?? defaultConsumerBuildOptions;
@@ -374,6 +375,7 @@ export class ConsumerOutputBuilder {
             sourcePath,
           });
         }
+        await this.emitConfigSourceFile(outputAppRoot, configSourcePath, runtimeSourcePaths);
       },
     });
   }
@@ -463,6 +465,24 @@ export class ConsumerOutputBuilder {
     }
   }
 
+  private async emitConfigSourceFile(
+    outputAppRoot: string,
+    configSourcePath: string,
+    runtimeSourcePaths: ReadonlyArray<string>,
+  ): Promise<void> {
+    const normalizedConfigSourcePath = path.resolve(configSourcePath);
+    const alreadyEmitted = runtimeSourcePaths.some(
+      (sourcePath) => path.resolve(sourcePath) === normalizedConfigSourcePath,
+    );
+    if (alreadyEmitted) {
+      return;
+    }
+    await this.emitSourceFile({
+      outputAppRoot,
+      sourcePath: normalizedConfigSourcePath,
+    });
+  }
+
   private createCompilerOptions(): ts.CompilerOptions {
     const scriptTarget = this.buildOptions.target === "es2020" ? ts.ScriptTarget.ES2020 : ts.ScriptTarget.ES2022;
     return {
@@ -697,6 +717,14 @@ export class ConsumerOutputBuilder {
   }
 
   private async resolveConfigPath(consumerRoot: string): Promise<string | null> {
+    const configuredOverride = this.configPathOverride?.trim();
+    if (configuredOverride && configuredOverride.length > 0) {
+      const resolvedOverride = path.resolve(configuredOverride);
+      if (await this.fileExists(resolvedOverride)) {
+        return resolvedOverride;
+      }
+      throw new Error(`Codemation config override not found at ${resolvedOverride}.`);
+    }
     for (const candidate of this.getConventionCandidates(consumerRoot)) {
       if (await this.fileExists(candidate)) {
         return candidate;

package/src/consumer/ConsumerOutputBuilderFactory.ts

@@ -0,0 +1,17 @@
+import type { Logger } from "@codemation/host/next/server";
+
+import { ConsumerOutputBuilder } from "./ConsumerOutputBuilder";
+import type { ConsumerBuildOptions } from "./consumerBuildOptions.types";
+
+export class ConsumerOutputBuilderFactory {
+  create(
+    consumerRoot: string,
+    args?: Readonly<{
+      buildOptions?: ConsumerBuildOptions;
+      configPathOverride?: string;
+      logger?: Logger;
+    }>,
+  ): ConsumerOutputBuilder {
+    return new ConsumerOutputBuilder(consumerRoot, args?.logger, args?.buildOptions, args?.configPathOverride);
+  }
+}

package/src/dev/Builder.ts

@@ -4,13 +4,13 @@ import { ConsumerEnvLoader } from "../consumer/ConsumerEnvLoader";
 import { ListenPortResolver } from "../runtime/ListenPortResolver";
 import { SourceMapNodeOptions } from "../runtime/SourceMapNodeOptions";
 
-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 { LoopbackPortAllocator } from "./LoopbackPortAllocator";
+import { NextHostEdgeSeedLoader } from "./NextHostEdgeSeedLoader";
 import { WatchRootsResolver } from "./WatchRootsResolver";
 
 export class DevSessionServicesBuilder {
@@ -25,7 +25,7 @@ export class DevSessionServicesBuilder {
       new DevSessionPortsResolver(listenPortResolver, loopbackPortAllocator),
       loopbackPortAllocator,
       new DevHttpProbe(),
-      new DevAuthSettingsLoader(new CodemationConsumerConfigLoader(), consumerEnvLoader),
+      new NextHostEdgeSeedLoader(new CodemationConsumerConfigLoader(), consumerEnvLoader),
       new DevNextHostEnvironmentBuilder(consumerEnvLoader, sourceMapNodeOptions),
       new WatchRootsResolver(),
       new DevSourceChangeClassifier(),

package/src/dev/CliDevProxyServer.ts

@@ -231,6 +231,19 @@ export class CliDevProxyServer {
     }
   }
 
+  private extractOccupyingPids(listenerDescription: string): ReadonlyArray<number> {
+    const seen = new Set<number>();
+    const re = /pid=(\d+)/g;
+    let match: RegExpExecArray | null;
+    while ((match = re.exec(listenerDescription)) !== null) {
+      const pid = Number.parseInt(match[1] ?? "0", 10);
+      if (Number.isFinite(pid) && pid > 0) {
+        seen.add(pid);
+      }
+    }
+    return [...seen];
+  }
+
   private async rejectListenError(error: unknown, reject: (reason?: unknown) => void): Promise<void> {
     const errorWithCode = error as Error & Readonly<{ code?: unknown }>;
     if (errorWithCode.code !== "EADDRINUSE") {
@@ -239,6 +252,13 @@ export class CliDevProxyServer {
     }
 
     const description = await this.listenPortConflictDescriber.describeLoopbackPort(this.listenPort);
+    const occupyingPids = description !== null ? this.extractOccupyingPids(description) : [];
+    if (occupyingPids.length > 0) {
+      const pidList = occupyingPids.join(", ");
+      process.stderr.write(
+        `[codemation] Dev gateway port ${this.listenPort} is already in use (occupying pid(s): ${pidList}).\n`,
+      );
+    }
     const baseMessage = `Dev gateway port ${this.listenPort} is already in use on 127.0.0.1.`;
     const suffix =
       description === null

package/src/dev/DevApiRuntimeFactory.ts

@@ -21,6 +21,7 @@ export class DevApiRuntimeFactory {
       httpPort,
       workflowWebSocketPort,
       new DevApiRuntimeHost(this.configLoader, this.pluginDiscovery, {
+        configPathOverride: args.configPathOverride,
         consumerRoot: args.consumerRoot,
         env: {
           ...args.env,

package/src/dev/DevApiRuntimeHost.ts

@@ -1,4 +1,5 @@
-import type { CodemationPlugin } from "@codemation/host";
+import type { AppConfig, AppPluginLoadSummary, CodemationPlugin } from "@codemation/host";
+import { CodemationPluginPackageMetadata } from "@codemation/host";
 import {
   AppContainerFactory,
   AppContainerLifecycle,
@@ -18,13 +19,15 @@ import { CodemationTsyringeTypeInfoRegistrar } from "@codemation/host-src/presen
 import type { DevApiRuntimeContext } from "./DevApiRuntimeTypes";
 
 export class DevApiRuntimeHost {
-  private readonly pluginListMerger = new CodemationPluginListMerger();
+  private readonly pluginPackageMetadata = new CodemationPluginPackageMetadata();
+  private readonly pluginListMerger = new CodemationPluginListMerger(this.pluginPackageMetadata);
   private contextPromise: Promise<DevApiRuntimeContext> | null = null;
 
   constructor(
     private readonly configLoader: AppConfigLoader,
     private readonly pluginDiscovery: CodemationPluginDiscovery,
     private readonly args: Readonly<{
+      configPathOverride?: string;
       consumerRoot: string;
       env: NodeJS.ProcessEnv;
       runtimeWorkingDirectory: string;
@@ -62,17 +65,24 @@ export class DevApiRuntimeHost {
     env.CODEMATION_CONSUMER_ROOT = consumerRoot;
     const configResolution = await this.configLoader.load({
       consumerRoot,
+      configPathOverride: this.args.configPathOverride,
       repoRoot,
       env,
     });
     const discoveredPlugins = await this.loadDiscoveredPlugins(consumerRoot);
+    const mergedPlugins =
+      discoveredPlugins.length > 0
+        ? this.pluginListMerger.merge(configResolution.appConfig.plugins, discoveredPlugins)
+        : configResolution.appConfig.plugins;
     const appConfig = {
       ...configResolution.appConfig,
       env,
-      plugins:
-        discoveredPlugins.length > 0
-          ? this.pluginListMerger.merge(configResolution.appConfig.plugins, discoveredPlugins)
-          : configResolution.appConfig.plugins,
+      plugins: mergedPlugins,
+      pluginLoadSummary: this.createPluginLoadSummary(
+        configResolution.appConfig.plugins,
+        discoveredPlugins,
+        mergedPlugins,
+      ),
     };
     const container = await new AppContainerFactory().create({
       appConfig,
@@ -96,6 +106,27 @@ export class DevApiRuntimeHost {
     return resolvedPackages.map((resolvedPackage: CodemationResolvedPluginPackage) => resolvedPackage.plugin);
   }
 
+  private createPluginLoadSummary(
+    configuredPlugins: ReadonlyArray<CodemationPlugin>,
+    discoveredPlugins: ReadonlyArray<CodemationPlugin>,
+    mergedPlugins: ReadonlyArray<CodemationPlugin>,
+  ): AppConfig["pluginLoadSummary"] {
+    const configuredPluginSet = new Set(configuredPlugins);
+    const discoveredPluginSet = new Set(discoveredPlugins);
+    const summaries: AppPluginLoadSummary[] = [];
+    for (const plugin of mergedPlugins) {
+      const packageName = this.pluginPackageMetadata.readPackageName(plugin);
+      if (!packageName) {
+        continue;
+      }
+      summaries.push({
+        packageName,
+        source: configuredPluginSet.has(plugin) || !discoveredPluginSet.has(plugin) ? "configured" : "discovered",
+      });
+    }
+    return summaries;
+  }
+
   private async detectWorkspaceRoot(startDirectory: string): Promise<string> {
     let currentDirectory = path.resolve(startDirectory);
     while (true) {

package/src/dev/DevApiRuntimeTypes.ts

@@ -10,6 +10,7 @@ export type DevApiRuntimeContext = Readonly<{
 }>;
 
 export type DevApiRuntimeFactoryArgs = Readonly<{
+  configPathOverride?: string;
   consumerRoot: string;
   env: NodeJS.ProcessEnv;
   runtimeWorkingDirectory: string;

package/src/dev/DevCliBannerRenderer.ts

@@ -39,8 +39,9 @@ export class DevCliBannerRenderer {
       title: chalk.bold("Runtime"),
       titleAlignment: "center",
     });
+    const pluginsSection = this.buildPluginsSection(summary);
     const activeSection = this.buildActiveWorkflowsSection(summary);
-    process.stdout.write(`${detailBox}\n${activeSection}\n`);
+    process.stdout.write(`${detailBox}\n${pluginsSection}\n${activeSection}\n`);
   }
 
   renderFull(summary: DevBootstrapSummaryJson): void {
@@ -62,8 +63,9 @@ export class DevCliBannerRenderer {
       title: chalk.bold("Runtime (updated)"),
       titleAlignment: "center",
     });
+    const pluginsSection = this.buildPluginsSection(summary);
     const activeSection = this.buildActiveWorkflowsSection(summary);
-    process.stdout.write(`\n${detailBox}\n${activeSection}\n`);
+    process.stdout.write(`\n${detailBox}\n${pluginsSection}\n${activeSection}\n`);
   }
 
   private renderFigletTitle(): string {
@@ -103,4 +105,21 @@ export class DevCliBannerRenderer {
       titleAlignment: "left",
     });
   }
+
+  private buildPluginsSection(summary: DevBootstrapSummaryJson): string {
+    const lines =
+      summary.plugins.length === 0
+        ? [chalk.dim("  (none discovered or configured)")]
+        : summary.plugins.map(
+            (plugin) => `${chalk.whiteBright(`  • ${plugin.packageName} `)}${chalk.dim(`(${plugin.source})`)}`,
+          );
+    return boxen(lines.join("\n"), {
+      padding: { top: 0, bottom: 0, left: 0, right: 0 },
+      margin: { top: 1, bottom: 0 },
+      borderStyle: "single",
+      borderColor: "cyan",
+      title: chalk.bold("Plugins"),
+      titleAlignment: "left",
+    });
+  }
 }

package/src/dev/DevNextHostEnvironmentBuilder.ts

@@ -1,7 +1,5 @@
 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";
@@ -10,14 +8,13 @@ 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(
     args: Readonly<{
-      authConfigJson: string;
       authSecret: string;
+      configPathOverride?: string;
+      consumerOutputManifestPath?: string;
       consumerRoot: string;
       developmentServerToken: string;
       nextPort: number;
@@ -25,69 +22,54 @@ export class DevNextHostEnvironmentBuilder {
       runtimeDevUrl: string;
       skipUiAuth: boolean;
       websocketPort: number;
-      consumerOutputManifestPath?: string;
     }>,
   ): NodeJS.ProcessEnv {
+    const publicWebsocketPort = this.resolvePublicWebsocketPort(args.publicBaseUrl, args.websocketPort);
     return {
       ...this.build({
-        authConfigJson: args.authConfigJson,
         authSecret: args.authSecret,
+        configPathOverride: args.configPathOverride,
+        consumerOutputManifestPath: args.consumerOutputManifestPath,
         consumerRoot: args.consumerRoot,
         developmentServerToken: args.developmentServerToken,
         nextPort: args.nextPort,
         runtimeDevUrl: args.runtimeDevUrl,
         skipUiAuth: args.skipUiAuth,
         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,
+      CODEMATION_PUBLIC_WS_PORT: String(publicWebsocketPort),
+      NEXT_PUBLIC_CODEMATION_WS_PORT: String(publicWebsocketPort),
     };
   }
 
   build(
     args: Readonly<{
-      authConfigJson: string;
       authSecret?: string;
+      configPathOverride?: string;
+      consumerOutputManifestPath?: string;
       consumerRoot: string;
       developmentServerToken: string;
       nextPort: number;
       skipUiAuth: boolean;
       websocketPort: number;
       runtimeDevUrl?: string;
-      /** Same manifest as `codemation build` / serve-web so @codemation/next-host can load consumer config (whitelabel, etc.). */
-      consumerOutputManifestPath?: string;
     }>,
   ): NodeJS.ProcessEnv {
     const merged = this.consumerEnvLoader.mergeConsumerRootIntoProcessEnvironment(args.consumerRoot, process.env);
-    const manifestPath =
+    const consumerOutputManifestPath =
       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_CONSUMER_ROOT: args.consumerRoot,
-      CODEMATION_CONSUMER_OUTPUT_MANIFEST_PATH: manifestPath,
-      CODEMATION_FRONTEND_APP_CONFIG_JSON: this.frontendAppConfigJsonCodec.serialize({
-        auth: authSnapshot,
-        productName: "Codemation",
-        logoUrl: null,
-      }),
+      CODEMATION_CONSUMER_OUTPUT_MANIFEST_PATH: consumerOutputManifestPath,
+      CODEMATION_UI_AUTH_ENABLED: String(!args.skipUiAuth),
+      CODEMATION_PUBLIC_WS_PORT: String(args.websocketPort),
       CODEMATION_WS_PORT: String(args.websocketPort),
       NEXT_PUBLIC_CODEMATION_WS_PORT: String(args.websocketPort),
       CODEMATION_DEV_SERVER_TOKEN: args.developmentServerToken,
@@ -95,17 +77,26 @@ export class DevNextHostEnvironmentBuilder {
       NODE_OPTIONS: this.sourceMapNodeOptions.appendToNodeOptions(process.env.NODE_OPTIONS),
       WS_NO_BUFFER_UTIL: "1",
       WS_NO_UTF_8_VALIDATE: "1",
+      ...(args.authSecret && args.authSecret.trim().length > 0 ? { AUTH_SECRET: args.authSecret.trim() } : {}),
+      ...(args.configPathOverride && args.configPathOverride.trim().length > 0
+        ? { CODEMATION_CONFIG_PATH: args.configPathOverride }
+        : {}),
       ...(args.runtimeDevUrl !== undefined && args.runtimeDevUrl.trim().length > 0
         ? { CODEMATION_RUNTIME_DEV_URL: args.runtimeDevUrl.trim() }
         : {}),
     };
   }
 
-  private parseAuthConfig(authConfigJson: string): CodemationAuthConfig | undefined {
-    if (authConfigJson.trim().length === 0) {
-      return undefined;
+  private resolvePublicWebsocketPort(publicBaseUrl: string, fallbackPort: number): number {
+    try {
+      const parsedUrl = new URL(publicBaseUrl);
+      const parsedPort = Number(parsedUrl.port);
+      if (Number.isInteger(parsedPort) && parsedPort > 0) {
+        return parsedPort;
+      }
+    } catch {
+      // Fall back to the runtime websocket port when the public URL is malformed.
     }
-    const parsed = JSON.parse(authConfigJson) as CodemationAuthConfig | null;
-    return parsed ?? undefined;
+    return fallbackPort;
   }
 }

package/src/dev/DevRebuildQueue.ts

@@ -1,6 +1,6 @@
 export type DevRebuildRequest = Readonly<{
   changedPaths: ReadonlyArray<string>;
-  shouldRepublishConsumerOutput: boolean;
+  configPathOverride?: string;
   shouldRestartUi: boolean;
 }>;
 
@@ -47,7 +47,7 @@ export class DevRebuildQueue {
     }
     return {
       changedPaths: [...new Set([...current.changedPaths, ...next.changedPaths])],
-      shouldRepublishConsumerOutput: current.shouldRepublishConsumerOutput || next.shouldRepublishConsumerOutput,
+      configPathOverride: next.configPathOverride ?? current.configPathOverride,
       shouldRestartUi: current.shouldRestartUi || next.shouldRestartUi,
     };
   }

package/src/dev/DevSessionServices.ts

@@ -1,12 +1,12 @@
 import { ConsumerEnvLoader } from "../consumer/ConsumerEnvLoader";
 import { SourceMapNodeOptions } from "../runtime/SourceMapNodeOptions";
 
-import { DevAuthSettingsLoader } from "./DevAuthSettingsLoader";
 import { DevHttpProbe } from "./DevHttpProbe";
 import { DevNextHostEnvironmentBuilder } from "./DevNextHostEnvironmentBuilder";
 import { DevSessionPortsResolver } from "./DevSessionPortsResolver";
 import { DevSourceChangeClassifier } from "./DevSourceChangeClassifier";
 import { LoopbackPortAllocator } from "./LoopbackPortAllocator";
+import { NextHostEdgeSeedLoader } from "./NextHostEdgeSeedLoader";
 import { WatchRootsResolver } from "./WatchRootsResolver";
 
 /**
@@ -19,7 +19,7 @@ export class DevSessionServices {
     readonly sessionPorts: DevSessionPortsResolver,
     readonly loopbackPortAllocator: LoopbackPortAllocator,
     readonly devHttpProbe: DevHttpProbe,
-    readonly devAuthLoader: DevAuthSettingsLoader,
+    readonly nextHostEdgeSeedLoader: NextHostEdgeSeedLoader,
     readonly nextHostEnvBuilder: DevNextHostEnvironmentBuilder,
     readonly watchRootsResolver: WatchRootsResolver,
     readonly sourceChangeClassifier: DevSourceChangeClassifier,

package/src/dev/DevSourceChangeClassifier.ts

@@ -1,21 +1,16 @@
 import path from "node:path";
 
 export class DevSourceChangeClassifier {
-  private static readonly configFileNames = new Set([
+  private static readonly uiConfigFileNames = new Set([
     "codemation.config.ts",
     "codemation.config.js",
     "codemation.config.mjs",
   ]);
-
-  shouldRepublishConsumerOutput(
-    args: Readonly<{
-      changedPaths: ReadonlyArray<string>;
-      consumerRoot: string;
-    }>,
-  ): boolean {
-    const resolvedConsumerRoot = path.resolve(args.consumerRoot);
-    return args.changedPaths.some((changedPath) => this.isPathInsideDirectory(changedPath, resolvedConsumerRoot));
-  }
+  private static readonly pluginConfigFileNames = new Set([
+    "codemation.plugin.ts",
+    "codemation.plugin.js",
+    "codemation.plugin.mjs",
+  ]);
 
   requiresUiRestart(
     args: Readonly<{
@@ -40,10 +35,15 @@ export class DevSourceChangeClassifier {
       return false;
     }
     const relativePath = path.relative(consumerRoot, resolvedPath);
-    if (DevSourceChangeClassifier.configFileNames.has(path.basename(relativePath))) {
+    const fileName = path.basename(relativePath);
+    if (DevSourceChangeClassifier.uiConfigFileNames.has(fileName)) {
       // Config changes affect auth and branding projections consumed by the packaged Next host.
       return true;
     }
+    if (DevSourceChangeClassifier.pluginConfigFileNames.has(fileName)) {
+      // Plugin sandbox configs also define workflows, so keep them on the cheap runtime-only reload path.
+      return false;
+    }
     if (relativePath.startsWith(path.join("src", "workflows"))) {
       return false;
     }