@codemation/cli 0.0.4 → 0.0.5

package/dist/{CliBin-900C8Din.js → CliBin-C3ar49fj.js}

@@ -155,9 +155,9 @@ var DevCommand = class {
 		});
 		const authSettings = await this.session.devAuthLoader.loadForConsumer(paths.consumerRoot);
 		const watcher = this.devSourceWatcherFactory.create();
+		const processState = this.createInitialProcessState();
 		try {
 			const prepared = await this.prepareDevRuntime(paths, devMode, nextPort, gatewayPort, authSettings);
-			const processState = this.createInitialProcessState();
 			const stopPromise = this.wireStopPromise(processState);
 			const uiProxyBase = await this.startConsumerUiProxyWhenNeeded(prepared, processState);
 			const gatewayBaseUrl = this.gatewayBaseHttpUrl(gatewayPort);
@@ -166,11 +166,13 @@ var DevCommand = class {
 			const initialSummary = await this.devBootstrapSummaryFetcher.fetch(gatewayBaseUrl);
 			if (initialSummary) this.devCliBannerRenderer.renderRuntimeSummary(initialSummary);
 			this.bindShutdownSignalsToChildProcesses(processState);
-			this.spawnFrameworkNextHostWhenNeeded(prepared, processState, gatewayBaseUrl);
-			await this.startWatcherForSourceRestart(prepared, watcher, devMode, gatewayBaseUrl);
+			await this.spawnFrameworkNextHostWhenNeeded(prepared, processState, gatewayBaseUrl);
+			await this.startWatcherForSourceRestart(prepared, processState, watcher, devMode, gatewayBaseUrl);
 			this.logConsumerDevHintWhenNeeded(devMode, gatewayPort);
 			await stopPromise;
 		} finally {
+			processState.stopRequested = true;
+			await this.stopLiveChildProcesses(processState);
 			await watcher.stop();
 			await devLock.release();
 		}
@@ -211,6 +213,8 @@ var DevCommand = class {
 			currentGateway: null,
 			currentNextHost: null,
 			currentUiNext: null,
+			currentUiProxyBaseUrl: null,
+			isRestartingNextHost: false,
 			stopRequested: false,
 			stopResolve: null,
 			stopReject: null
@@ -232,48 +236,46 @@ var DevCommand = class {
 	async startConsumerUiProxyWhenNeeded(prepared, state) {
 		if (prepared.devMode !== "consumer") return "";
 		const websocketPort = prepared.gatewayPort;
-		const uiPort = await this.session.loopbackPortAllocator.allocate();
-		const uiProxyBase = `http://127.0.0.1:${uiPort}`;
+		const uiProxyBase = state.currentUiProxyBaseUrl ?? `http://127.0.0.1:${await this.session.loopbackPortAllocator.allocate()}`;
+		state.currentUiProxyBaseUrl = uiProxyBase;
+		await this.spawnConsumerUiProxy(prepared, state, prepared.authSettings, websocketPort, uiProxyBase);
+		return uiProxyBase;
+	}
+	async spawnConsumerUiProxy(prepared, state, authSettings, websocketPort, uiProxyBase) {
 		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,
+			consumerRoot: prepared.paths.consumerRoot,
+			consumerOutputManifestPath,
+			developmentServerToken: prepared.developmentServerToken,
+			nextPort: uiPort,
+			publicBaseUrl: this.gatewayBaseHttpUrl(prepared.gatewayPort),
+			runtimeDevUrl: this.gatewayBaseHttpUrl(prepared.gatewayPort),
+			skipUiAuth: authSettings.skipUiAuth,
+			websocketPort
+		});
 		state.currentUiNext = spawn(nextHostCommand.command, nextHostCommand.args, {
 			cwd: nextHostCommand.cwd,
 			...this.devDetachedChildSpawnOptions(),
-			env: {
-				...process$1.env,
-				...prepared.consumerEnv,
-				PORT: String(uiPort),
-				CODEMATION_AUTH_CONFIG_JSON: prepared.authSettings.authConfigJson,
-				CODEMATION_CONSUMER_ROOT: prepared.paths.consumerRoot,
-				CODEMATION_CONSUMER_OUTPUT_MANIFEST_PATH: consumerOutputManifestPath,
-				CODEMATION_SKIP_UI_AUTH: prepared.authSettings.skipUiAuth ? "true" : "false",
-				AUTH_SECRET: prepared.authSettings.authSecret,
-				NEXTAUTH_SECRET: prepared.authSettings.authSecret,
-				NEXT_PUBLIC_CODEMATION_SKIP_UI_AUTH: prepared.authSettings.skipUiAuth ? "true" : "false",
-				CODEMATION_WS_PORT: String(websocketPort),
-				NEXT_PUBLIC_CODEMATION_WS_PORT: String(websocketPort),
-				CODEMATION_DEV_SERVER_TOKEN: prepared.developmentServerToken,
-				NODE_OPTIONS: this.session.sourceMapNodeOptions.appendToNodeOptions(process$1.env.NODE_OPTIONS),
-				WS_NO_BUFFER_UTIL: "1",
-				WS_NO_UTF_8_VALIDATE: "1"
-			}
+			env: nextHostEnvironment
 		});
 		state.currentUiNext.on("error", (error) => {
-			if (!state.stopRequested) {
-				state.stopRequested = true;
-				state.stopReject?.(error instanceof Error ? error : new Error(String(error)));
-			}
+			if (state.stopRequested || state.isRestartingNextHost) return;
+			state.stopRequested = true;
+			state.stopReject?.(error instanceof Error ? error : new Error(String(error)));
 		});
 		state.currentUiNext.on("exit", (code) => {
-			if (state.stopRequested) return;
+			if (state.stopRequested || state.isRestartingNextHost) return;
 			state.stopRequested = true;
 			if (state.currentGateway?.exitCode === null) this.devTrackedProcessTreeKiller.killProcessTreeRootedAt(state.currentGateway);
 			state.stopReject?.(/* @__PURE__ */ new Error(`next start (consumer UI) exited unexpectedly with code ${code ?? 0}.`));
 		});
 		await this.session.devHttpProbe.waitUntilUrlRespondsOk(`${uiProxyBase}/`);
-		return uiProxyBase;
 	}
 	async spawnGatewayChildAndWaitForHealth(prepared, state, gatewayBaseUrl, uiProxyBase) {
 		const gatewayProcessEnv = this.session.consumerEnvLoader.mergeIntoProcessEnvironment(process$1.env, prepared.consumerEnv);
@@ -350,17 +352,20 @@ var DevCommand = class {
 	/**
 	* Framework mode: run `next dev` for the Next host with HMR, pointed at the dev gateway runtime URL.
 	*/
-	spawnFrameworkNextHostWhenNeeded(prepared, state, gatewayBaseUrl) {
+	async spawnFrameworkNextHostWhenNeeded(prepared, state, gatewayBaseUrl) {
 		if (prepared.devMode !== "framework") return;
+		await this.spawnFrameworkNextHost(prepared, state, gatewayBaseUrl, prepared.authSettings);
+	}
+	async spawnFrameworkNextHost(prepared, state, gatewayBaseUrl, authSettings) {
 		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: prepared.authSettings.authConfigJson,
+			authConfigJson: authSettings.authConfigJson,
 			consumerRoot: prepared.paths.consumerRoot,
 			developmentServerToken: prepared.developmentServerToken,
 			nextPort: prepared.nextPort,
-			skipUiAuth: prepared.authSettings.skipUiAuth,
+			skipUiAuth: authSettings.skipUiAuth,
 			websocketPort,
 			runtimeDevUrl: gatewayBaseUrl
 		});
@@ -375,7 +380,7 @@ var DevCommand = class {
 		});
 		state.currentNextHost.on("exit", (code) => {
 			const normalizedCode = code ?? 0;
-			if (state.stopRequested) return;
+			if (state.stopRequested || state.isRestartingNextHost) return;
 			if (normalizedCode === 0) {
 				state.stopRequested = true;
 				if (state.currentGateway?.exitCode === null) this.devTrackedProcessTreeKiller.killProcessTreeRootedAt(state.currentGateway);
@@ -386,13 +391,13 @@ var DevCommand = class {
 			state.stopReject?.(/* @__PURE__ */ new Error(`next host exited with code ${normalizedCode}.`));
 		});
 		state.currentNextHost.on("error", (error) => {
-			if (!state.stopRequested) {
-				state.stopRequested = true;
-				state.stopReject?.(error instanceof Error ? error : new Error(String(error)));
-			}
+			if (state.stopRequested || state.isRestartingNextHost) return;
+			state.stopRequested = true;
+			state.stopReject?.(error instanceof Error ? error : new Error(String(error)));
 		});
+		await this.session.devHttpProbe.waitUntilUrlRespondsOk(`http://127.0.0.1:${prepared.nextPort}/`);
 	}
-	async startWatcherForSourceRestart(prepared, watcher, devMode, gatewayBaseUrl) {
+	async startWatcherForSourceRestart(prepared, state, watcher, devMode, gatewayBaseUrl) {
 		await watcher.start({
 			roots: this.session.watchRootsResolver.resolve({
 				consumerRoot: prepared.paths.consumerRoot,
@@ -404,16 +409,71 @@ var DevCommand = class {
 					process$1.stdout.write("\n[codemation] Consumer environment file changed (e.g. .env). Restart the `codemation dev` process so the gateway and runtime pick up updated variables (host `process.env` does not hot-reload).\n");
 					return;
 				}
-				process$1.stdout.write("\n[codemation] Source change detected — rebuilding consumer…\n");
-				await this.session.sourceRestartCoordinator.runHandshakeAfterSourceChange(gatewayBaseUrl, prepared.developmentServerToken);
-				process$1.stdout.write("[codemation] Waiting for runtime to accept traffic…\n");
-				await this.session.devHttpProbe.waitUntilBootstrapSummaryReady(gatewayBaseUrl);
-				const json = await this.devBootstrapSummaryFetcher.fetch(gatewayBaseUrl);
-				if (json) this.devCliBannerRenderer.renderCompact(json);
-				process$1.stdout.write("[codemation] Runtime ready.\n");
+				try {
+					const shouldRepublishConsumerOutput = this.session.sourceChangeClassifier.shouldRepublishConsumerOutput({
+						changedPaths,
+						consumerRoot: prepared.paths.consumerRoot
+					});
+					const shouldRestartNextHost = this.session.sourceChangeClassifier.requiresNextHostRestart({
+						changedPaths,
+						consumerRoot: prepared.paths.consumerRoot
+					});
+					process$1.stdout.write(shouldRestartNextHost ? "\n[codemation] Consumer config change detected — rebuilding consumer, restarting runtime, and restarting Next host…\n" : "\n[codemation] Source change detected — rebuilding consumer and restarting runtime…\n");
+					if (shouldRepublishConsumerOutput) await this.devConsumerPublishBootstrap.ensurePublished(prepared.paths);
+					await this.session.sourceRestartCoordinator.runHandshakeAfterSourceChange(gatewayBaseUrl, prepared.developmentServerToken);
+					process$1.stdout.write("[codemation] Waiting for runtime to accept traffic…\n");
+					await this.session.devHttpProbe.waitUntilBootstrapSummaryReady(gatewayBaseUrl);
+					if (shouldRestartNextHost) await this.restartNextHostForConfigChange(prepared, state, gatewayBaseUrl);
+					const json = await this.devBootstrapSummaryFetcher.fetch(gatewayBaseUrl);
+					if (json) this.devCliBannerRenderer.renderCompact(json);
+					process$1.stdout.write("[codemation] Runtime ready.\n");
+				} catch (error) {
+					await this.failDevSessionAfterIrrecoverableSourceError(state, error);
+				}
 			}
 		});
 	}
+	async restartNextHostForConfigChange(prepared, state, gatewayBaseUrl) {
+		const refreshedAuthSettings = await this.session.devAuthLoader.loadForConsumer(prepared.paths.consumerRoot);
+		process$1.stdout.write("[codemation] Restarting Next host to apply auth/database/scheduler/branding changes…\n");
+		state.isRestartingNextHost = true;
+		try {
+			if (prepared.devMode === "consumer") {
+				await this.restartConsumerUiProxy(prepared, state, refreshedAuthSettings);
+				return;
+			}
+			await this.restartFrameworkNextHost(prepared, state, gatewayBaseUrl, refreshedAuthSettings);
+		} finally {
+			state.isRestartingNextHost = false;
+		}
+	}
+	async restartConsumerUiProxy(prepared, state, authSettings) {
+		if (state.currentUiNext && state.currentUiNext.exitCode === null && state.currentUiNext.signalCode === null) await this.devTrackedProcessTreeKiller.killProcessTreeRootedAt(state.currentUiNext);
+		state.currentUiNext = null;
+		const uiProxyBaseUrl = state.currentUiProxyBaseUrl;
+		if (!uiProxyBaseUrl) throw new Error("Consumer UI proxy base URL is missing during Next host restart.");
+		await this.spawnConsumerUiProxy(prepared, state, authSettings, prepared.gatewayPort, uiProxyBaseUrl);
+	}
+	async restartFrameworkNextHost(prepared, state, gatewayBaseUrl, authSettings) {
+		if (state.currentNextHost && state.currentNextHost.exitCode === null && state.currentNextHost.signalCode === null) await this.devTrackedProcessTreeKiller.killProcessTreeRootedAt(state.currentNextHost);
+		state.currentNextHost = null;
+		await this.spawnFrameworkNextHost(prepared, state, gatewayBaseUrl, authSettings);
+	}
+	async failDevSessionAfterIrrecoverableSourceError(state, error) {
+		const exception = error instanceof Error ? error : new Error(String(error));
+		state.stopRequested = true;
+		await this.stopLiveChildProcesses(state);
+		state.stopReject?.(exception);
+	}
+	async stopLiveChildProcesses(state) {
+		const children = [];
+		for (const child of [
+			state.currentUiNext,
+			state.currentNextHost,
+			state.currentGateway
+		]) if (child && child.exitCode === null && child.signalCode === null) children.push(child);
+		await Promise.all(children.map((child) => this.devTrackedProcessTreeKiller.killProcessTreeRootedAt(child)));
+	}
 	logConsumerDevHintWhenNeeded(devMode, gatewayPort) {
 		if (devMode !== "consumer") return;
 		this.cliLogger.info(`codemation dev (consumer): open http://127.0.0.1:${gatewayPort} — uses the packaged @codemation/next-host UI. For framework UI HMR, set CODEMATION_DEV_MODE=framework.`);
@@ -1532,8 +1592,8 @@ var DevHttpProbe = class {
 	async waitUntilUrlRespondsOk(url) {
 		for (let attempt = 0; attempt < 200; attempt += 1) {
 			try {
-				const response = await fetch(url);
-				if (response.ok || response.status === 404) return;
+				const response = await fetch(url, { redirect: "manual" });
+				if (response.ok || response.status === 404 || this.isRedirectStatus(response.status)) return;
 			} catch {}
 			await setTimeout$1(50);
 		}
@@ -1562,6 +1622,9 @@ var DevHttpProbe = class {
 		}
 		throw new Error("Timed out waiting for dev runtime bootstrap summary.");
 	}
+	isRedirectStatus(status) {
+		return status >= 300 && status < 400;
+	}
 };
 
 //#endregion
@@ -1571,6 +1634,24 @@ var DevNextHostEnvironmentBuilder = class {
 		this.consumerEnvLoader = consumerEnvLoader;
 		this.sourceMapNodeOptions = sourceMapNodeOptions;
 	}
+	buildConsumerUiProxy(args) {
+		return {
+			...this.build({
+				authConfigJson: args.authConfigJson,
+				consumerRoot: args.consumerRoot,
+				developmentServerToken: args.developmentServerToken,
+				nextPort: args.nextPort,
+				runtimeDevUrl: args.runtimeDevUrl,
+				skipUiAuth: args.skipUiAuth,
+				websocketPort: args.websocketPort,
+				consumerOutputManifestPath: args.consumerOutputManifestPath
+			}),
+			AUTH_SECRET: args.authSecret,
+			AUTH_URL: args.publicBaseUrl,
+			NEXTAUTH_SECRET: args.authSecret,
+			NEXTAUTH_URL: args.publicBaseUrl
+		};
+	}
 	build(args) {
 		const merged = this.consumerEnvLoader.mergeConsumerRootIntoProcessEnvironment(args.consumerRoot, process$1.env);
 		const manifestPath = args.consumerOutputManifestPath ?? path.resolve(args.consumerRoot, ".codemation", "output", "current.json");
@@ -1616,7 +1697,7 @@ var DevSessionPortsResolver = class {
 * Bundles dependencies for {@link DevCommand} so the command stays a thin orchestrator.
 */
 var DevSessionServices = class {
-	constructor(consumerEnvLoader, sourceMapNodeOptions, sessionPorts, loopbackPortAllocator, devHttpProbe, runtimeEntrypointResolver, devAuthLoader, nextHostEnvBuilder, watchRootsResolver, sourceRestartCoordinator) {
+	constructor(consumerEnvLoader, sourceMapNodeOptions, sessionPorts, loopbackPortAllocator, devHttpProbe, runtimeEntrypointResolver, devAuthLoader, nextHostEnvBuilder, watchRootsResolver, sourceChangeClassifier, sourceRestartCoordinator) {
 		this.consumerEnvLoader = consumerEnvLoader;
 		this.sourceMapNodeOptions = sourceMapNodeOptions;
 		this.sessionPorts = sessionPorts;
@@ -1626,10 +1707,38 @@ var DevSessionServices = class {
 		this.devAuthLoader = devAuthLoader;
 		this.nextHostEnvBuilder = nextHostEnvBuilder;
 		this.watchRootsResolver = watchRootsResolver;
+		this.sourceChangeClassifier = sourceChangeClassifier;
 		this.sourceRestartCoordinator = sourceRestartCoordinator;
 	}
 };
 
+//#endregion
+//#region src/dev/DevSourceChangeClassifier.ts
+var DevSourceChangeClassifier = class {
+	shouldRepublishConsumerOutput(args) {
+		const resolvedConsumerRoot = path.resolve(args.consumerRoot);
+		return args.changedPaths.some((changedPath) => this.isPathInsideDirectory(changedPath, resolvedConsumerRoot));
+	}
+	requiresNextHostRestart(args) {
+		const configPaths = new Set(this.resolveConfigPaths(args.consumerRoot));
+		return args.changedPaths.some((changedPath) => configPaths.has(path.resolve(changedPath)));
+	}
+	resolveConfigPaths(consumerRoot) {
+		const resolvedConsumerRoot = path.resolve(consumerRoot);
+		return [
+			path.resolve(resolvedConsumerRoot, "codemation.config.ts"),
+			path.resolve(resolvedConsumerRoot, "codemation.config.js"),
+			path.resolve(resolvedConsumerRoot, "src", "codemation.config.ts"),
+			path.resolve(resolvedConsumerRoot, "src", "codemation.config.js")
+		];
+	}
+	isPathInsideDirectory(filePath, directoryPath) {
+		const resolvedFilePath = path.resolve(filePath);
+		const relativePath = path.relative(directoryPath, resolvedFilePath);
+		return relativePath.length === 0 || !relativePath.startsWith("..") && !path.isAbsolute(relativePath);
+	}
+};
+
 //#endregion
 //#region src/dev/DevSourceRestartCoordinator.ts
 var DevSourceRestartCoordinator = class {
@@ -1754,7 +1863,7 @@ var DevSessionServicesBuilder = class {
 		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 DevNextHostEnvironmentBuilder(consumerEnvLoader, sourceMapNodeOptions), new WatchRootsResolver(), new DevSourceRestartCoordinator(new DevelopmentGatewayNotifier(cliLogger), this.loggerFactory.createPerformanceDiagnostics("codemation-cli.performance"), cliLogger));
+		return new DevSessionServices(consumerEnvLoader, sourceMapNodeOptions, new DevSessionPortsResolver(listenPortResolver, loopbackPortAllocator), loopbackPortAllocator, new DevHttpProbe(), new RuntimeToolEntrypointResolver(), new DevAuthSettingsLoader(new CodemationConsumerConfigLoader()), new DevNextHostEnvironmentBuilder(consumerEnvLoader, sourceMapNodeOptions), new WatchRootsResolver(), new DevSourceChangeClassifier(), new DevSourceRestartCoordinator(new DevelopmentGatewayNotifier(cliLogger), this.loggerFactory.createPerformanceDiagnostics("codemation-cli.performance"), cliLogger));
 	}
 };
 

package/dist/bin.js

@@ -1,4 +1,4 @@
-import { t as CliBin } from "./CliBin-900C8Din.js";
+import { t as CliBin } from "./CliBin-C3ar49fj.js";
 import process from "node:process";
 import "reflect-metadata";
 

package/dist/index.d.ts

@@ -23118,6 +23118,7 @@ declare class DevHttpProbe {
    * Polls until the runtime child serves bootstrap summary (after gateway is up, the disposable runtime may still be wiring).
    */
   waitUntilBootstrapSummaryReady(gatewayBaseUrl: string): Promise<void>;
+  private isRedirectStatus;
 }
 //#endregion
 //#region src/dev/DevNextHostEnvironmentBuilder.d.ts
@@ -23125,6 +23126,18 @@ declare class DevNextHostEnvironmentBuilder {
   private readonly consumerEnvLoader;
   private readonly sourceMapNodeOptions;
   constructor(consumerEnvLoader: ConsumerEnvLoader, sourceMapNodeOptions: SourceMapNodeOptions);
+  buildConsumerUiProxy(args: Readonly<{
+    authConfigJson: string;
+    authSecret: string;
+    consumerRoot: string;
+    developmentServerToken: string;
+    nextPort: number;
+    publicBaseUrl: string;
+    runtimeDevUrl: string;
+    skipUiAuth: boolean;
+    websocketPort: number;
+    consumerOutputManifestPath?: string;
+  }>): NodeJS.ProcessEnv;
   build(args: Readonly<{
     authConfigJson: string;
     consumerRoot: string;
@@ -23172,6 +23185,20 @@ declare class DevSessionPortsResolver {
   }>>;
 }
 //#endregion
+//#region src/dev/DevSourceChangeClassifier.d.ts
+declare class DevSourceChangeClassifier {
+  shouldRepublishConsumerOutput(args: Readonly<{
+    changedPaths: ReadonlyArray<string>;
+    consumerRoot: string;
+  }>): boolean;
+  requiresNextHostRestart(args: Readonly<{
+    changedPaths: ReadonlyArray<string>;
+    consumerRoot: string;
+  }>): boolean;
+  private resolveConfigPaths;
+  private isPathInsideDirectory;
+}
+//#endregion
 //#region src/dev/DevelopmentGatewayNotifier.d.ts
 declare class DevelopmentGatewayNotifier {
   private readonly cliLogger;
@@ -23235,8 +23262,9 @@ declare class DevSessionServices {
   readonly devAuthLoader: DevAuthSettingsLoader;
   readonly nextHostEnvBuilder: DevNextHostEnvironmentBuilder;
   readonly watchRootsResolver: WatchRootsResolver;
+  readonly sourceChangeClassifier: DevSourceChangeClassifier;
   readonly sourceRestartCoordinator: DevSourceRestartCoordinator;
-  constructor(consumerEnvLoader: ConsumerEnvLoader, sourceMapNodeOptions: SourceMapNodeOptions, sessionPorts: DevSessionPortsResolver, loopbackPortAllocator: LoopbackPortAllocator, devHttpProbe: DevHttpProbe, runtimeEntrypointResolver: RuntimeToolEntrypointResolver, devAuthLoader: DevAuthSettingsLoader, nextHostEnvBuilder: DevNextHostEnvironmentBuilder, watchRootsResolver: WatchRootsResolver, sourceRestartCoordinator: DevSourceRestartCoordinator);
+  constructor(consumerEnvLoader: ConsumerEnvLoader, sourceMapNodeOptions: SourceMapNodeOptions, sessionPorts: DevSessionPortsResolver, loopbackPortAllocator: LoopbackPortAllocator, devHttpProbe: DevHttpProbe, runtimeEntrypointResolver: RuntimeToolEntrypointResolver, devAuthLoader: DevAuthSettingsLoader, nextHostEnvBuilder: DevNextHostEnvironmentBuilder, watchRootsResolver: WatchRootsResolver, sourceChangeClassifier: DevSourceChangeClassifier, sourceRestartCoordinator: DevSourceRestartCoordinator);
 }
 //#endregion
 //#region src/dev/DevLock.d.ts
@@ -23345,6 +23373,7 @@ declare class DevCommand {
    * Framework mode: no separate UI child (Next runs in dev later).
    */
   private startConsumerUiProxyWhenNeeded;
+  private spawnConsumerUiProxy;
   private spawnGatewayChildAndWaitForHealth;
   private devDetachedChildSpawnOptions;
   private bindShutdownSignalsToChildProcesses;
@@ -23352,7 +23381,13 @@ declare class DevCommand {
    * Framework mode: run `next dev` for the Next host with HMR, pointed at the dev gateway runtime URL.
    */
   private spawnFrameworkNextHostWhenNeeded;
+  private spawnFrameworkNextHost;
   private startWatcherForSourceRestart;
+  private restartNextHostForConfigChange;
+  private restartConsumerUiProxy;
+  private restartFrameworkNextHost;
+  private failDevSessionAfterIrrecoverableSourceError;
+  private stopLiveChildProcesses;
   private logConsumerDevHintWhenNeeded;
 }
 //#endregion

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-900C8Din.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-C3ar49fj.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.4",
+  "version": "0.0.5",
   "publishConfig": {
     "access": "public"
   },
@@ -28,11 +28,11 @@
     "figlet": "^1.11.0",
     "reflect-metadata": "^0.2.2",
     "typescript": "^5.9.3",
-    "@codemation/dev-gateway": "0.0.4",
-    "@codemation/host": "0.0.4",
-    "@codemation/next-host": "0.0.4",
-    "@codemation/worker-cli": "0.0.4",
-    "@codemation/runtime-dev": "0.0.4"
+    "@codemation/dev-gateway": "0.0.5",
+    "@codemation/host": "0.0.5",
+    "@codemation/next-host": "0.0.5",
+    "@codemation/runtime-dev": "0.0.5",
+    "@codemation/worker-cli": "0.0.5"
   },
   "devDependencies": {
     "@types/node": "^25.3.5",

package/src/commands/DevCommand.ts

@@ -62,9 +62,9 @@ export class DevCommand {
     });
     const authSettings = await this.session.devAuthLoader.loadForConsumer(paths.consumerRoot);
     const watcher = this.devSourceWatcherFactory.create();
+    const processState = this.createInitialProcessState();
     try {
       const prepared = await this.prepareDevRuntime(paths, devMode, nextPort, gatewayPort, authSettings);
-      const processState = this.createInitialProcessState();
       const stopPromise = this.wireStopPromise(processState);
       const uiProxyBase = await this.startConsumerUiProxyWhenNeeded(prepared, processState);
       const gatewayBaseUrl = this.gatewayBaseHttpUrl(gatewayPort);
@@ -75,11 +75,13 @@ export class DevCommand {
         this.devCliBannerRenderer.renderRuntimeSummary(initialSummary);
       }
       this.bindShutdownSignalsToChildProcesses(processState);
-      this.spawnFrameworkNextHostWhenNeeded(prepared, processState, gatewayBaseUrl);
-      await this.startWatcherForSourceRestart(prepared, watcher, devMode, gatewayBaseUrl);
+      await this.spawnFrameworkNextHostWhenNeeded(prepared, processState, gatewayBaseUrl);
+      await this.startWatcherForSourceRestart(prepared, processState, watcher, devMode, gatewayBaseUrl);
       this.logConsumerDevHintWhenNeeded(devMode, gatewayPort);
       await stopPromise;
     } finally {
+      processState.stopRequested = true;
+      await this.stopLiveChildProcesses(processState);
       await watcher.stop();
       await devLock.release();
     }
@@ -132,6 +134,8 @@ export class DevCommand {
       currentGateway: null,
       currentNextHost: null,
       currentUiNext: null,
+      currentUiProxyBaseUrl: null,
+      isRestartingNextHost: false,
       stopRequested: false,
       stopResolve: null,
       stopReject: null,
@@ -161,8 +165,19 @@ export class DevCommand {
       return "";
     }
     const websocketPort = prepared.gatewayPort;
-    const uiPort = await this.session.loopbackPortAllocator.allocate();
-    const uiProxyBase = `http://127.0.0.1:${uiPort}`;
+    const uiProxyBase = state.currentUiProxyBaseUrl ?? `http://127.0.0.1:${await this.session.loopbackPortAllocator.allocate()}`;
+    state.currentUiProxyBaseUrl = uiProxyBase;
+    await this.spawnConsumerUiProxy(prepared, state, prepared.authSettings, websocketPort, uiProxyBase);
+    return uiProxyBase;
+  }
+
+  private async spawnConsumerUiProxy(
+    prepared: DevPreparedRuntime,
+    state: DevMutableProcessState,
+    authSettings: DevResolvedAuthSettings,
+    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 });
@@ -172,36 +187,33 @@ export class DevCommand {
       "output",
       "current.json",
     );
+    const uiPort = Number(new URL(uiProxyBase).port);
+    const nextHostEnvironment = this.session.nextHostEnvBuilder.buildConsumerUiProxy({
+      authConfigJson: authSettings.authConfigJson,
+      authSecret: authSettings.authSecret,
+      consumerRoot: prepared.paths.consumerRoot,
+      consumerOutputManifestPath,
+      developmentServerToken: prepared.developmentServerToken,
+      nextPort: uiPort,
+      publicBaseUrl: this.gatewayBaseHttpUrl(prepared.gatewayPort),
+      runtimeDevUrl: this.gatewayBaseHttpUrl(prepared.gatewayPort),
+      skipUiAuth: authSettings.skipUiAuth,
+      websocketPort,
+    });
     state.currentUiNext = spawn(nextHostCommand.command, nextHostCommand.args, {
       cwd: nextHostCommand.cwd,
       ...this.devDetachedChildSpawnOptions(),
-      env: {
-        ...process.env,
-        ...prepared.consumerEnv,
-        PORT: String(uiPort),
-        CODEMATION_AUTH_CONFIG_JSON: prepared.authSettings.authConfigJson,
-        CODEMATION_CONSUMER_ROOT: prepared.paths.consumerRoot,
-        CODEMATION_CONSUMER_OUTPUT_MANIFEST_PATH: consumerOutputManifestPath,
-        CODEMATION_SKIP_UI_AUTH: prepared.authSettings.skipUiAuth ? "true" : "false",
-        AUTH_SECRET: prepared.authSettings.authSecret,
-        NEXTAUTH_SECRET: prepared.authSettings.authSecret,
-        NEXT_PUBLIC_CODEMATION_SKIP_UI_AUTH: prepared.authSettings.skipUiAuth ? "true" : "false",
-        CODEMATION_WS_PORT: String(websocketPort),
-        NEXT_PUBLIC_CODEMATION_WS_PORT: String(websocketPort),
-        CODEMATION_DEV_SERVER_TOKEN: prepared.developmentServerToken,
-        NODE_OPTIONS: this.session.sourceMapNodeOptions.appendToNodeOptions(process.env.NODE_OPTIONS),
-        WS_NO_BUFFER_UTIL: "1",
-        WS_NO_UTF_8_VALIDATE: "1",
-      },
+      env: nextHostEnvironment,
     });
     state.currentUiNext.on("error", (error) => {
-      if (!state.stopRequested) {
-        state.stopRequested = true;
-        state.stopReject?.(error instanceof Error ? error : new Error(String(error)));
+      if (state.stopRequested || state.isRestartingNextHost) {
+        return;
       }
+      state.stopRequested = true;
+      state.stopReject?.(error instanceof Error ? error : new Error(String(error)));
     });
     state.currentUiNext.on("exit", (code) => {
-      if (state.stopRequested) {
+      if (state.stopRequested || state.isRestartingNextHost) {
         return;
       }
       state.stopRequested = true;
@@ -211,7 +223,6 @@ export class DevCommand {
       state.stopReject?.(new Error(`next start (consumer UI) exited unexpectedly with code ${code ?? 0}.`));
     });
     await this.session.devHttpProbe.waitUntilUrlRespondsOk(`${uiProxyBase}/`);
-    return uiProxyBase;
   }
 
   private async spawnGatewayChildAndWaitForHealth(
@@ -301,23 +312,32 @@ export class DevCommand {
   /**
    * Framework mode: run `next dev` for the Next host with HMR, pointed at the dev gateway runtime URL.
    */
-  private spawnFrameworkNextHostWhenNeeded(
+  private async spawnFrameworkNextHostWhenNeeded(
     prepared: DevPreparedRuntime,
     state: DevMutableProcessState,
     gatewayBaseUrl: string,
-  ): void {
+  ): Promise<void> {
     if (prepared.devMode !== "framework") {
       return;
     }
+    await this.spawnFrameworkNextHost(prepared, state, gatewayBaseUrl, prepared.authSettings);
+  }
+
+  private async spawnFrameworkNextHost(
+    prepared: DevPreparedRuntime,
+    state: DevMutableProcessState,
+    gatewayBaseUrl: string,
+    authSettings: DevResolvedAuthSettings,
+  ): 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: prepared.authSettings.authConfigJson,
+      authConfigJson: authSettings.authConfigJson,
       consumerRoot: prepared.paths.consumerRoot,
       developmentServerToken: prepared.developmentServerToken,
       nextPort: prepared.nextPort,
-      skipUiAuth: prepared.authSettings.skipUiAuth,
+      skipUiAuth: authSettings.skipUiAuth,
       websocketPort,
       runtimeDevUrl: gatewayBaseUrl,
     });
@@ -328,7 +348,7 @@ export class DevCommand {
     });
     state.currentNextHost.on("exit", (code) => {
       const normalizedCode = code ?? 0;
-      if (state.stopRequested) {
+      if (state.stopRequested || state.isRestartingNextHost) {
         return;
       }
       if (normalizedCode === 0) {
@@ -343,15 +363,18 @@ export class DevCommand {
       state.stopReject?.(new Error(`next host exited with code ${normalizedCode}.`));
     });
     state.currentNextHost.on("error", (error) => {
-      if (!state.stopRequested) {
-        state.stopRequested = true;
-        state.stopReject?.(error instanceof Error ? error : new Error(String(error)));
+      if (state.stopRequested || state.isRestartingNextHost) {
+        return;
       }
+      state.stopRequested = true;
+      state.stopReject?.(error instanceof Error ? error : new Error(String(error)));
     });
+    await this.session.devHttpProbe.waitUntilUrlRespondsOk(`http://127.0.0.1:${prepared.nextPort}/`);
   }
 
   private async startWatcherForSourceRestart(
     prepared: DevPreparedRuntime,
+    state: DevMutableProcessState,
     watcher: DevSourceWatcher,
     devMode: DevMode,
     gatewayBaseUrl: string,
@@ -369,22 +392,112 @@ export class DevCommand {
           );
           return;
         }
-        process.stdout.write("\n[codemation] Source change detected — rebuilding consumer…\n");
-        await this.session.sourceRestartCoordinator.runHandshakeAfterSourceChange(
-          gatewayBaseUrl,
-          prepared.developmentServerToken,
-        );
-        process.stdout.write("[codemation] Waiting for runtime to accept traffic…\n");
-        await this.session.devHttpProbe.waitUntilBootstrapSummaryReady(gatewayBaseUrl);
-        const json = await this.devBootstrapSummaryFetcher.fetch(gatewayBaseUrl);
-        if (json) {
-          this.devCliBannerRenderer.renderCompact(json);
+        try {
+          const shouldRepublishConsumerOutput = this.session.sourceChangeClassifier.shouldRepublishConsumerOutput({
+            changedPaths,
+            consumerRoot: prepared.paths.consumerRoot,
+          });
+          const shouldRestartNextHost = this.session.sourceChangeClassifier.requiresNextHostRestart({
+            changedPaths,
+            consumerRoot: prepared.paths.consumerRoot,
+          });
+          process.stdout.write(
+            shouldRestartNextHost
+              ? "\n[codemation] Consumer config change detected — rebuilding consumer, restarting runtime, and restarting Next host…\n"
+              : "\n[codemation] Source change detected — rebuilding consumer and restarting runtime…\n",
+          );
+          if (shouldRepublishConsumerOutput) {
+            await this.devConsumerPublishBootstrap.ensurePublished(prepared.paths);
+          }
+          await this.session.sourceRestartCoordinator.runHandshakeAfterSourceChange(
+            gatewayBaseUrl,
+            prepared.developmentServerToken,
+          );
+          process.stdout.write("[codemation] Waiting for runtime to accept traffic…\n");
+          await this.session.devHttpProbe.waitUntilBootstrapSummaryReady(gatewayBaseUrl);
+          if (shouldRestartNextHost) {
+            await this.restartNextHostForConfigChange(prepared, state, gatewayBaseUrl);
+          }
+          const json = await this.devBootstrapSummaryFetcher.fetch(gatewayBaseUrl);
+          if (json) {
+            this.devCliBannerRenderer.renderCompact(json);
+          }
+          process.stdout.write("[codemation] Runtime ready.\n");
+        } catch (error) {
+          await this.failDevSessionAfterIrrecoverableSourceError(state, error);
         }
-        process.stdout.write("[codemation] Runtime ready.\n");
       },
     });
   }
 
+  private async restartNextHostForConfigChange(
+    prepared: DevPreparedRuntime,
+    state: DevMutableProcessState,
+    gatewayBaseUrl: string,
+  ): Promise<void> {
+    const refreshedAuthSettings = await this.session.devAuthLoader.loadForConsumer(prepared.paths.consumerRoot);
+    process.stdout.write("[codemation] Restarting Next host to apply auth/database/scheduler/branding changes…\n");
+    state.isRestartingNextHost = true;
+    try {
+      if (prepared.devMode === "consumer") {
+        await this.restartConsumerUiProxy(prepared, state, refreshedAuthSettings);
+        return;
+      }
+      await this.restartFrameworkNextHost(prepared, state, gatewayBaseUrl, refreshedAuthSettings);
+    } finally {
+      state.isRestartingNextHost = false;
+    }
+  }
+
+  private async restartConsumerUiProxy(
+    prepared: DevPreparedRuntime,
+    state: DevMutableProcessState,
+    authSettings: DevResolvedAuthSettings,
+  ): Promise<void> {
+    if (state.currentUiNext && state.currentUiNext.exitCode === null && state.currentUiNext.signalCode === null) {
+      await this.devTrackedProcessTreeKiller.killProcessTreeRootedAt(state.currentUiNext);
+    }
+    state.currentUiNext = null;
+    const uiProxyBaseUrl = state.currentUiProxyBaseUrl;
+    if (!uiProxyBaseUrl) {
+      throw new Error("Consumer UI proxy base URL is missing during Next host restart.");
+    }
+    await this.spawnConsumerUiProxy(prepared, state, authSettings, prepared.gatewayPort, uiProxyBaseUrl);
+  }
+
+  private async restartFrameworkNextHost(
+    prepared: DevPreparedRuntime,
+    state: DevMutableProcessState,
+    gatewayBaseUrl: string,
+    authSettings: DevResolvedAuthSettings,
+  ): Promise<void> {
+    if (state.currentNextHost && state.currentNextHost.exitCode === null && state.currentNextHost.signalCode === null) {
+      await this.devTrackedProcessTreeKiller.killProcessTreeRootedAt(state.currentNextHost);
+    }
+    state.currentNextHost = null;
+    await this.spawnFrameworkNextHost(prepared, state, gatewayBaseUrl, authSettings);
+  }
+
+  private async failDevSessionAfterIrrecoverableSourceError(
+    state: DevMutableProcessState,
+    error: unknown,
+  ): Promise<void> {
+    const exception = error instanceof Error ? error : new Error(String(error));
+    state.stopRequested = true;
+    await this.stopLiveChildProcesses(state);
+    state.stopReject?.(exception);
+  }
+
+  private async stopLiveChildProcesses(state: DevMutableProcessState): Promise<void> {
+    const children: ChildProcess[] = [];
+    for (const child of [state.currentUiNext, state.currentNextHost, state.currentGateway]) {
+      if (child && child.exitCode === null && child.signalCode === null) {
+        children.push(child);
+      }
+    }
+    await Promise.all(children.map((child) => this.devTrackedProcessTreeKiller.killProcessTreeRootedAt(child)));
+  }
+
   private logConsumerDevHintWhenNeeded(devMode: DevMode, gatewayPort: number): void {
     if (devMode !== "consumer") {
       return;

package/src/commands/devCommandLifecycle.types.ts

@@ -11,6 +11,8 @@ export type DevMutableProcessState = {
   currentGateway: ChildProcess | null;
   currentNextHost: ChildProcess | null;
   currentUiNext: ChildProcess | null;
+  currentUiProxyBaseUrl: string | null;
+  isRestartingNextHost: boolean;
   stopRequested: boolean;
   stopResolve: (() => void) | null;
   stopReject: ((error: Error) => void) | null;

package/src/dev/Builder.ts

@@ -11,6 +11,7 @@ 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";
@@ -35,6 +36,7 @@ export class DevSessionServicesBuilder {
       new DevAuthSettingsLoader(new CodemationConsumerConfigLoader()),
       new DevNextHostEnvironmentBuilder(consumerEnvLoader, sourceMapNodeOptions),
       new WatchRootsResolver(),
+      new DevSourceChangeClassifier(),
       new DevSourceRestartCoordinator(
         new DevelopmentGatewayNotifier(cliLogger),
         this.loggerFactory.createPerformanceDiagnostics("codemation-cli.performance"),

package/src/dev/DevHttpProbe.ts

@@ -4,8 +4,8 @@ export class DevHttpProbe {
   async waitUntilUrlRespondsOk(url: string): Promise<void> {
     for (let attempt = 0; attempt < 200; attempt += 1) {
       try {
-        const response = await fetch(url);
-        if (response.ok || response.status === 404) {
+        const response = await fetch(url, { redirect: "manual" });
+        if (response.ok || response.status === 404 || this.isRedirectStatus(response.status)) {
           return;
         }
       } catch {
@@ -51,4 +51,8 @@ export class DevHttpProbe {
     }
     throw new Error("Timed out waiting for dev runtime bootstrap summary.");
   }
+
+  private isRedirectStatus(status: number): boolean {
+    return status >= 300 && status < 400;
+  }
 }

package/src/dev/DevNextHostEnvironmentBuilder.ts

@@ -10,6 +10,38 @@ export class DevNextHostEnvironmentBuilder {
     private readonly sourceMapNodeOptions: SourceMapNodeOptions,
   ) {}
 
+  buildConsumerUiProxy(
+    args: Readonly<{
+      authConfigJson: string;
+      authSecret: string;
+      consumerRoot: string;
+      developmentServerToken: string;
+      nextPort: number;
+      publicBaseUrl: string;
+      runtimeDevUrl: string;
+      skipUiAuth: boolean;
+      websocketPort: number;
+      consumerOutputManifestPath?: string;
+    }>,
+  ): NodeJS.ProcessEnv {
+    return {
+      ...this.build({
+        authConfigJson: args.authConfigJson,
+        consumerRoot: args.consumerRoot,
+        developmentServerToken: args.developmentServerToken,
+        nextPort: args.nextPort,
+        runtimeDevUrl: args.runtimeDevUrl,
+        skipUiAuth: args.skipUiAuth,
+        websocketPort: args.websocketPort,
+        consumerOutputManifestPath: args.consumerOutputManifestPath,
+      }),
+      AUTH_SECRET: args.authSecret,
+      AUTH_URL: args.publicBaseUrl,
+      NEXTAUTH_SECRET: args.authSecret,
+      NEXTAUTH_URL: args.publicBaseUrl,
+    };
+  }
+
   build(
     args: Readonly<{
       authConfigJson: string;

package/src/dev/DevSessionServices.ts

@@ -5,6 +5,7 @@ import { DevAuthSettingsLoader } from "./DevAuthSettingsLoader";
 import { DevHttpProbe } from "./DevHttpProbe";
 import { DevNextHostEnvironmentBuilder } from "./DevNextHostEnvironmentBuilder";
 import { DevSessionPortsResolver } from "./DevSessionPortsResolver";
+import { DevSourceChangeClassifier } from "./DevSourceChangeClassifier";
 import { DevSourceRestartCoordinator } from "./DevSourceRestartCoordinator";
 import { LoopbackPortAllocator } from "./LoopbackPortAllocator";
 import { RuntimeToolEntrypointResolver } from "./RuntimeToolEntrypointResolver";
@@ -24,6 +25,7 @@ export class DevSessionServices {
     readonly devAuthLoader: DevAuthSettingsLoader,
     readonly nextHostEnvBuilder: DevNextHostEnvironmentBuilder,
     readonly watchRootsResolver: WatchRootsResolver,
+    readonly sourceChangeClassifier: DevSourceChangeClassifier,
     readonly sourceRestartCoordinator: DevSourceRestartCoordinator,
   ) {}
 }

package/src/dev/DevSourceChangeClassifier.ts

@@ -0,0 +1,39 @@
+import path from "node:path";
+
+export class DevSourceChangeClassifier {
+  shouldRepublishConsumerOutput(
+    args: Readonly<{
+      changedPaths: ReadonlyArray<string>;
+      consumerRoot: string;
+    }>,
+  ): boolean {
+    const resolvedConsumerRoot = path.resolve(args.consumerRoot);
+    return args.changedPaths.some((changedPath) => this.isPathInsideDirectory(changedPath, resolvedConsumerRoot));
+  }
+
+  requiresNextHostRestart(
+    args: Readonly<{
+      changedPaths: ReadonlyArray<string>;
+      consumerRoot: string;
+    }>,
+  ): boolean {
+    const configPaths = new Set(this.resolveConfigPaths(args.consumerRoot));
+    return args.changedPaths.some((changedPath) => configPaths.has(path.resolve(changedPath)));
+  }
+
+  private resolveConfigPaths(consumerRoot: string): ReadonlyArray<string> {
+    const resolvedConsumerRoot = path.resolve(consumerRoot);
+    return [
+      path.resolve(resolvedConsumerRoot, "codemation.config.ts"),
+      path.resolve(resolvedConsumerRoot, "codemation.config.js"),
+      path.resolve(resolvedConsumerRoot, "src", "codemation.config.ts"),
+      path.resolve(resolvedConsumerRoot, "src", "codemation.config.js"),
+    ];
+  }
+
+  private isPathInsideDirectory(filePath: string, directoryPath: string): boolean {
+    const resolvedFilePath = path.resolve(filePath);
+    const relativePath = path.relative(directoryPath, resolvedFilePath);
+    return relativePath.length === 0 || (!relativePath.startsWith("..") && !path.isAbsolute(relativePath));
+  }
+}