@codemation/cli 0.0.16 → 0.0.19

package/CHANGELOG.md

@@ -0,0 +1,18 @@
+# @codemation/cli
+
+## 0.0.19
+
+### Patch Changes
+
+- Updated dependencies [[`405c854`](https://github.com/MadeRelevant/codemation/commit/405c8541961f41dcba653f352691a821b0470ca0)]:
+  - @codemation/host@0.0.19
+  - @codemation/next-host@0.0.19
+
+## 0.0.18
+
+### Patch Changes
+
+- f0c6878: Introduce Changesets, a single CI status check for branch protection, and the Codemation pre-stable license across published packages.
+- Updated dependencies [f0c6878]
+  - @codemation/host@0.0.18
+  - @codemation/next-host@0.0.18

package/LICENSE

@@ -0,0 +1,37 @@
+Codemation Pre-Stable License
+
+Copyright (c) Made Relevant B.V. All rights reserved.
+
+1. Definitions
+
+   "Software" means the Codemation source code, documentation, and artifacts in this repository and any published npm packages in the Codemation monorepo.
+
+   "Stable Version" means the first published release of the package `@codemation/core` on the public npm registry with version 1.0.0 or higher.
+
+2. Permitted use (before Stable Version)
+
+   Until a Stable Version exists, you may use, copy, modify, and distribute the Software only for non-commercial purposes, including personal learning, research, evaluation, and internal use within your organization that does not charge third parties for access to the Software or a product or service whose primary value is the Software.
+
+3. Restrictions (before Stable Version)
+
+   Until a Stable Version exists, you must not:
+
+   a) Sell, rent, lease, or sublicense the Software or a derivative work for a fee;
+
+   b) Offer the Software or a derivative work as part of a paid product or service (including hosting, support, or consulting) where the Software is a material part of the offering;
+
+   c) Use the Software or a derivative work primarily to generate revenue or commercial advantage for you or others.
+
+   These restrictions apply to all versions published before a Stable Version, even if a later Stable Version is released under different terms.
+
+4. After Stable Version
+
+   The maintainers may publish a Stable Version under different license terms. If they do, those terms apply only to that Stable Version and subsequent releases they designate; they do not automatically apply to earlier pre-stable versions.
+
+5. No warranty
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+6. Third-party components
+
+   The Software may include third-party components under their own licenses. Those licenses govern those components.

package/dist/{CliBin-C31h2o8w.js → CliBin-BYHuUedo.js}

@@ -3,15 +3,15 @@ import process$1 from "node:process";
 import { AppConfigLoader, CodemationConsumerConfigLoader, CodemationPluginDiscovery, WorkflowDiscoveryPathSegmentsComputer, WorkflowModulePathFinder } from "@codemation/host/server";
 import { ApiPaths, AppContainerFactory, AppContainerLifecycle, ApplicationTokens, CodemationPluginPackageMetadata, DatabaseMigrations, ListUserAccountsQuery, PrismaClient, UpsertLocalBootstrapUserCommand, WorkerRuntime } from "@codemation/host";
 import { AppContainerFactory as AppContainerFactory$1, AppContainerLifecycle as AppContainerLifecycle$1, CodemationHonoApiApp, CodemationPluginListMerger, FrontendRuntime, ServerLoggerFactory, logLevelPolicyFactory } from "@codemation/host/next/server";
-import { execFile, spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { access, copyFile, cp, mkdir, open, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
 import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { execFile, spawn } from "node:child_process";
 import { existsSync, readFileSync } from "node:fs";
 import { config, parse } from "dotenv";
 import { watch } from "chokidar";
-import { randomUUID } from "node:crypto";
-import { access, copyFile, cp, mkdir, open, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
 import ts from "typescript";
-import { fileURLToPath } from "node:url";
 import { PrismaMigrationDeployer } from "@codemation/host/persistence";
 import boxen from "boxen";
 import chalk from "chalk";
@@ -41,20 +41,74 @@ var ConsumerBuildOptionsParser = class {
 	}
 };
 
+//#endregion
+//#region src/build/ConsumerBuildArtifactsPublisher.ts
+var ConsumerBuildArtifactsPublisher = class {
+	async publish(snapshot, discoveredPlugins) {
+		const pluginEntryPath = await this.writeDiscoveredPluginsOutput(snapshot, discoveredPlugins);
+		return await this.writeBuildManifest(snapshot, pluginEntryPath);
+	}
+	async writeDiscoveredPluginsOutput(snapshot, discoveredPlugins) {
+		const outputPath = path.resolve(snapshot.emitOutputRoot, "plugins.js");
+		await mkdir(path.dirname(outputPath), { recursive: true });
+		const outputLines = ["const codemationDiscoveredPlugins = [];", ""];
+		discoveredPlugins.forEach((discoveredPlugin, index) => {
+			const pluginFileUrl = pathToFileURL(path.resolve(discoveredPlugin.packageRoot, this.resolvePluginEntry(discoveredPlugin))).href;
+			outputLines.push(`const pluginModule${index} = await import(${JSON.stringify(pluginFileUrl)});`);
+			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(`} else if (typeof pluginValue${index} === "function" && pluginValue${index}.prototype && typeof pluginValue${index}.prototype.register === "function") {`);
+			outputLines.push(`  codemationDiscoveredPlugins.push(new pluginValue${index}());`);
+			outputLines.push("}");
+			outputLines.push("");
+		});
+		outputLines.push("export { codemationDiscoveredPlugins };");
+		outputLines.push("export default codemationDiscoveredPlugins;");
+		outputLines.push("");
+		await writeFile(outputPath, outputLines.join("\n"), "utf8");
+		return outputPath;
+	}
+	async writeBuildManifest(snapshot, pluginEntryPath) {
+		const manifest = {
+			buildVersion: snapshot.buildVersion,
+			consumerRoot: snapshot.consumerRoot,
+			entryPath: snapshot.outputEntryPath,
+			manifestPath: snapshot.manifestPath,
+			pluginEntryPath,
+			workflowSourcePaths: snapshot.workflowSourcePaths
+		};
+		await mkdir(path.dirname(snapshot.manifestPath), { recursive: true });
+		const temporaryManifestPath = `${snapshot.manifestPath}.${snapshot.buildVersion}.${randomUUID()}.tmp`;
+		await writeFile(temporaryManifestPath, JSON.stringify(manifest, null, 2), "utf8");
+		await rename(temporaryManifestPath, snapshot.manifestPath);
+		return manifest;
+	}
+	resolvePluginEntry(discoveredPlugin) {
+		if (typeof discoveredPlugin.developmentEntry === "string" && discoveredPlugin.developmentEntry.trim().length > 0) return discoveredPlugin.developmentEntry;
+		return discoveredPlugin.pluginEntry;
+	}
+};
+
 //#endregion
 //#region src/commands/BuildCommand.ts
 var BuildCommand = class {
-	constructor(cliLogger, pathResolver, consumerOutputBuilderFactory, tsRuntime) {
+	constructor(cliLogger, pathResolver, consumerOutputBuilderFactory, pluginDiscovery, consumerBuildArtifactsPublisher, tsRuntime) {
 		this.cliLogger = cliLogger;
 		this.pathResolver = pathResolver;
 		this.consumerOutputBuilderFactory = consumerOutputBuilderFactory;
+		this.pluginDiscovery = pluginDiscovery;
+		this.consumerBuildArtifactsPublisher = consumerBuildArtifactsPublisher;
 		this.tsRuntime = tsRuntime;
 	}
 	async execute(consumerRoot, buildOptions) {
 		const paths = await this.pathResolver.resolve(consumerRoot);
 		this.tsRuntime.configure(paths.repoRoot);
 		const snapshot = await this.consumerOutputBuilderFactory.create(paths.consumerRoot, { buildOptions }).ensureBuilt();
+		const discoveredPlugins = await this.pluginDiscovery.discover(paths.consumerRoot);
+		const manifest = await this.consumerBuildArtifactsPublisher.publish(snapshot, discoveredPlugins);
 		this.cliLogger.info(`Built consumer output: ${snapshot.outputEntryPath}`);
+		this.cliLogger.info(`Build manifest: ${manifest.manifestPath}`);
 		this.cliLogger.info(`Workflow modules emitted: ${snapshot.workflowSourcePaths.length}`);
 	}
 };
@@ -74,7 +128,7 @@ var DbMigrateCommand = class {
 //#region src/commands/DevCommand.ts
 var DevCommand = class {
 	require = createRequire(import.meta.url);
-	constructor(pathResolver, tsRuntime, devLockFactory, devSourceWatcherFactory, cliLogger, session, databaseMigrationsApplyService, devBootstrapSummaryFetcher, devCliBannerRenderer, consumerEnvDotenvFilePredicate, devTrackedProcessTreeKiller, nextHostConsumerServerCommandFactory, devApiRuntimeFactory, cliDevProxyServerFactory, devRebuildQueueFactory) {
+	constructor(pathResolver, tsRuntime, devLockFactory, devSourceWatcherFactory, cliLogger, session, databaseMigrationsApplyService, consumerOutputBuilderFactory, pluginDiscovery, consumerBuildArtifactsPublisher, devBootstrapSummaryFetcher, devCliBannerRenderer, consumerEnvDotenvFilePredicate, devTrackedProcessTreeKiller, nextHostConsumerServerCommandFactory, devApiRuntimeFactory, cliDevProxyServerFactory, devRebuildQueueFactory) {
 		this.pathResolver = pathResolver;
 		this.tsRuntime = tsRuntime;
 		this.devLockFactory = devLockFactory;
@@ -82,6 +136,9 @@ var DevCommand = class {
 		this.cliLogger = cliLogger;
 		this.session = session;
 		this.databaseMigrationsApplyService = databaseMigrationsApplyService;
+		this.consumerOutputBuilderFactory = consumerOutputBuilderFactory;
+		this.pluginDiscovery = pluginDiscovery;
+		this.consumerBuildArtifactsPublisher = consumerBuildArtifactsPublisher;
 		this.devBootstrapSummaryFetcher = devBootstrapSummaryFetcher;
 		this.devCliBannerRenderer = devCliBannerRenderer;
 		this.consumerEnvDotenvFilePredicate = consumerEnvDotenvFilePredicate;
@@ -94,6 +151,7 @@ var DevCommand = class {
 	async execute(args) {
 		const paths = await this.pathResolver.resolve(args.consumerRoot);
 		const commandName = args.commandName ?? "dev";
+		const previousDevelopmentServerToken = process$1.env.CODEMATION_DEV_SERVER_TOKEN;
 		this.devCliBannerRenderer.renderBrandHeader();
 		this.tsRuntime.configure(paths.repoRoot);
 		await this.databaseMigrationsApplyService.applyForConsumer(paths.consumerRoot, { configPath: args.configPathOverride });
@@ -114,6 +172,8 @@ var DevCommand = class {
 		let proxyServer = null;
 		try {
 			const prepared = await this.prepareDevRuntime(paths, devMode, nextPort, gatewayPort, authSettings, args.configPathOverride);
+			if (prepared.devMode === "packaged-ui") await this.publishConsumerArtifacts(prepared.paths, prepared.configPathOverride);
+			process$1.env.CODEMATION_DEV_SERVER_TOKEN = prepared.developmentServerToken;
 			const stopPromise = this.wireStopPromise(processState);
 			const uiProxyBase = await this.preparePackagedUiBaseUrlWhenNeeded(prepared, processState);
 			proxyServer = await this.startProxyServer(prepared.gatewayPort, uiProxyBase);
@@ -132,6 +192,8 @@ var DevCommand = class {
 			this.logPackagedUiDevHintWhenNeeded(devMode, gatewayPort, commandName);
 			await stopPromise;
 		} finally {
+			if (previousDevelopmentServerToken === void 0) delete process$1.env.CODEMATION_DEV_SERVER_TOKEN;
+			else process$1.env.CODEMATION_DEV_SERVER_TOKEN = previousDevelopmentServerToken;
 			processState.stopRequested = true;
 			await this.stopLiveProcesses(processState, proxyServer);
 			await watcher.stop();
@@ -345,6 +407,7 @@ var DevCommand = class {
 		proxyServer.setBuildStatus("building");
 		proxyServer.broadcastBuildStarted();
 		try {
+			if (prepared.devMode === "packaged-ui") await this.publishConsumerArtifacts(prepared.paths, request.configPathOverride);
 			await this.stopCurrentRuntime(state, proxyServer);
 			process$1.stdout.write("[codemation] Waiting for runtime to accept traffic…\n");
 			const runtime = await this.createRuntime(prepared);
@@ -353,11 +416,11 @@ var DevCommand = class {
 				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");
+			if (request.shouldRestartUi) await this.restartUiAfterSourceChange(prepared, state, gatewayBaseUrl);
 			proxyServer.broadcastBuildCompleted(runtime.buildVersion);
 			process$1.stdout.write("[codemation] Runtime ready.\n");
 		} catch (error) {
@@ -427,6 +490,12 @@ var DevCommand = class {
 			}
 		});
 	}
+	async publishConsumerArtifacts(paths, configPathOverride) {
+		const snapshot = await this.consumerOutputBuilderFactory.create(paths.consumerRoot, { configPathOverride }).ensureBuilt();
+		const discoveredPlugins = await this.pluginDiscovery.discover(paths.consumerRoot);
+		await this.consumerBuildArtifactsPublisher.publish(snapshot, discoveredPlugins);
+		this.cliLogger.debug(`Dev: consumer output published (${snapshot.buildVersion}).`);
+	}
 	logPackagedUiDevHintWhenNeeded(devMode, gatewayPort, commandName) {
 		if (devMode !== "packaged-ui") return;
 		this.cliLogger.info(`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.`);
@@ -712,8 +781,9 @@ var ConsumerOutputBuilder = class ConsumerOutputBuilder {
 	lastIssuedBuildVersion = 0;
 	log;
 	buildOptions;
-	constructor(consumerRoot, logOverride, buildOptionsOverride) {
+	constructor(consumerRoot, logOverride, buildOptionsOverride, configPathOverride) {
 		this.consumerRoot = consumerRoot;
+		this.configPathOverride = configPathOverride;
 		this.log = logOverride ?? defaultConsumerOutputLogger;
 		this.buildOptions = buildOptionsOverride ?? defaultConsumerBuildOptions;
 	}
@@ -1132,6 +1202,12 @@ var ConsumerOutputBuilder = class ConsumerOutputBuilder {
 		return `${nextBuildVersion}-${process$1.pid}`;
 	}
 	async resolveConfigPath(consumerRoot) {
+		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;
 		return null;
 	}
@@ -1248,7 +1324,7 @@ var ConsumerOutputBuilder = class ConsumerOutputBuilder {
 //#region src/consumer/ConsumerOutputBuilderFactory.ts
 var ConsumerOutputBuilderFactory = class {
 	create(consumerRoot, args) {
-		return new ConsumerOutputBuilder(consumerRoot, args?.logger, args?.buildOptions);
+		return new ConsumerOutputBuilder(consumerRoot, args?.logger, args?.buildOptions, args?.configPathOverride);
 	}
 };
 
@@ -1699,12 +1775,27 @@ var CliDevProxyServer = class {
 			return url.split("?")[0] ?? url;
 		}
 	}
+	extractOccupyingPids(listenerDescription) {
+		const seen = /* @__PURE__ */ new Set();
+		const re = /pid=(\d+)/g;
+		let match;
+		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];
+	}
 	async rejectListenError(error, reject) {
 		if (error.code !== "EADDRINUSE") {
 			reject(error);
 			return;
 		}
 		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 ? " Stop the process using that port or change the configured Codemation dev port." : ` Listener: ${description}. Stop that process or change the configured Codemation dev port.`;
 		reject(new Error(`${baseMessage}${suffix}`, { cause: error instanceof Error ? error : void 0 }));
@@ -1882,12 +1973,19 @@ var ListenPortConflictDescriber = class {
 	async describeLoopbackPort(port) {
 		if (!Number.isInteger(port) || port <= 0) return null;
 		if (this.platform !== "linux" && this.platform !== "darwin") return null;
-		const raw = await this.readLsofOutput(port);
-		if (raw === null) return null;
-		const occupants = this.parseLsofOutput(raw);
+		const occupants = await this.resolveLoopbackOccupants(port);
 		if (occupants.length === 0) return null;
 		return occupants.map((occupant) => `pid=${occupant.pid} command=${occupant.command} endpoint=${occupant.endpoint}`).join("; ");
 	}
+	async resolveLoopbackOccupants(port) {
+		const lsofRaw = await this.readLsofOutput(port);
+		const fromLsof = lsofRaw !== null ? this.parseLsofOutput(lsofRaw) : [];
+		if (fromLsof.length > 0) return fromLsof;
+		if (this.platform !== "linux") return [];
+		const ssRaw = await this.readSsOutput(port);
+		if (ssRaw === null) return [];
+		return this.parseSsListenOutput(ssRaw, port);
+	}
 	async readLsofOutput(port) {
 		try {
 			return await new Promise((resolve, reject) => {
@@ -1933,6 +2031,44 @@ var ListenPortConflictDescriber = class {
 		}
 		return occupants;
 	}
+	async readSsOutput(port) {
+		const filtered = await this.execFileStdout("ss", ["-lntp", `sport = :${port}`]);
+		if (filtered !== null && filtered.trim().length > 0) return filtered;
+		return this.execFileStdout("ss", ["-lntp"]);
+	}
+	async execFileStdout(command, args) {
+		try {
+			return await new Promise((resolve, reject) => {
+				execFile(command, [...args], (error, stdout) => {
+					if (error) {
+						reject(error);
+						return;
+					}
+					resolve(stdout);
+				});
+			});
+		} catch {
+			return null;
+		}
+	}
+	parseSsListenOutput(raw, port) {
+		const occupants = [];
+		const portSuffix = `:${port}`;
+		for (const line of raw.split("\n")) {
+			if (!line.includes("LISTEN") || !line.includes(portSuffix)) continue;
+			const pidMatch = line.match(/pid=(\d+)/);
+			if (!pidMatch) continue;
+			const pid = Number.parseInt(pidMatch[1] ?? "0", 10);
+			const command = line.match(/users:\(\("([^"]*)"/)?.[1] ?? "unknown";
+			const endpoint = line.match(/\s+(\S+:\d+|\[[^\]]+\]:\d+)\s+/)?.[1] ?? `tcp:${String(port)}`;
+			occupants.push({
+				pid,
+				command,
+				endpoint
+			});
+		}
+		return occupants;
+	}
 };
 
 //#endregion
@@ -2387,10 +2523,12 @@ var DevNextHostEnvironmentBuilder = class {
 		this.sourceMapNodeOptions = sourceMapNodeOptions;
 	}
 	buildConsumerUiProxy(args) {
+		const publicWebsocketPort = this.resolvePublicWebsocketPort(args.publicBaseUrl, args.websocketPort);
 		return {
 			...this.build({
 				authSecret: args.authSecret,
 				configPathOverride: args.configPathOverride,
+				consumerOutputManifestPath: args.consumerOutputManifestPath,
 				consumerRoot: args.consumerRoot,
 				developmentServerToken: args.developmentServerToken,
 				nextPort: args.nextPort,
@@ -2400,15 +2538,21 @@ var DevNextHostEnvironmentBuilder = class {
 			}),
 			HOSTNAME: "127.0.0.1",
 			AUTH_SECRET: args.authSecret,
-			AUTH_URL: args.publicBaseUrl
+			AUTH_URL: args.publicBaseUrl,
+			CODEMATION_PUBLIC_WS_PORT: String(publicWebsocketPort),
+			NEXT_PUBLIC_CODEMATION_WS_PORT: String(publicWebsocketPort)
 		};
 	}
 	build(args) {
+		const merged = this.consumerEnvLoader.mergeConsumerRootIntoProcessEnvironment(args.consumerRoot, process$1.env);
+		const consumerOutputManifestPath = args.consumerOutputManifestPath ?? path.resolve(args.consumerRoot, ".codemation", "output", "current.json");
 		return {
-			...this.consumerEnvLoader.mergeConsumerRootIntoProcessEnvironment(args.consumerRoot, process$1.env),
+			...merged,
 			PORT: String(args.nextPort),
 			CODEMATION_CONSUMER_ROOT: args.consumerRoot,
+			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,
@@ -2421,6 +2565,14 @@ var DevNextHostEnvironmentBuilder = class {
 			...args.runtimeDevUrl !== void 0 && args.runtimeDevUrl.trim().length > 0 ? { CODEMATION_RUNTIME_DEV_URL: args.runtimeDevUrl.trim() } : {}
 		};
 	}
+	resolvePublicWebsocketPort(publicBaseUrl, fallbackPort) {
+		try {
+			const parsedUrl = new URL(publicBaseUrl);
+			const parsedPort = Number(parsedUrl.port);
+			if (Number.isInteger(parsedPort) && parsedPort > 0) return parsedPort;
+		} catch {}
+		return fallbackPort;
+	}
 };
 
 //#endregion
@@ -3180,8 +3332,10 @@ var CliProgramFactory = class {
 		const userAdminCliOptionsParser = new UserAdminCliOptionsParser();
 		const databaseMigrationsApplyService = new DatabaseMigrationsApplyService(cliLogger, new UserAdminConsumerDotenvLoader(), tsconfigPreparation, new CodemationConsumerConfigLoader(), new ConsumerDatabaseConnectionResolver(), new CliDatabaseUrlDescriptor(), hostPackageRoot, new PrismaMigrationDeployer());
 		const buildOptionsParser = new ConsumerBuildOptionsParser();
-		const devCommand = new DevCommand(pathResolver, tsRuntime, new DevLockFactory(), new DevSourceWatcherFactory(), cliLogger, devSessionServices, databaseMigrationsApplyService, new DevBootstrapSummaryFetcher(), new DevCliBannerRenderer(), new ConsumerEnvDotenvFilePredicate(), new DevTrackedProcessTreeKiller(), nextHostConsumerServerCommandFactory, new DevApiRuntimeFactory(devSessionServices.loopbackPortAllocator, appConfigLoader, pluginDiscovery), new CliDevProxyServerFactory(), new DevRebuildQueueFactory());
-		return new CliProgram(buildOptionsParser, new BuildCommand(cliLogger, pathResolver, new ConsumerOutputBuilderFactory(), tsRuntime), devCommand, new DevPluginCommand(new PluginDevConfigFactory(), devCommand), new ServeWebCommand(pathResolver, new CodemationConsumerConfigLoader(), tsRuntime, sourceMapNodeOptions, new ConsumerEnvLoader(), new ListenPortResolver(), nextHostConsumerServerCommandFactory), new ServeWorkerCommand(pathResolver, appConfigLoader, new AppContainerFactory()), new DbMigrateCommand(databaseMigrationsApplyService), new UserCreateCommand(new LocalUserCreator(userAdminBootstrap), userAdminCliOptionsParser), new UserListCommand(cliLogger, userAdminBootstrap, new CliDatabaseUrlDescriptor(), userAdminCliOptionsParser));
+		const consumerOutputBuilderFactory = new ConsumerOutputBuilderFactory();
+		const consumerBuildArtifactsPublisher = new ConsumerBuildArtifactsPublisher();
+		const devCommand = new DevCommand(pathResolver, tsRuntime, new DevLockFactory(), new DevSourceWatcherFactory(), cliLogger, devSessionServices, databaseMigrationsApplyService, consumerOutputBuilderFactory, pluginDiscovery, 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, consumerOutputBuilderFactory, pluginDiscovery, consumerBuildArtifactsPublisher, tsRuntime), devCommand, new DevPluginCommand(new PluginDevConfigFactory(), devCommand), new ServeWebCommand(pathResolver, new CodemationConsumerConfigLoader(), tsRuntime, sourceMapNodeOptions, new ConsumerEnvLoader(), new ListenPortResolver(), nextHostConsumerServerCommandFactory), new ServeWorkerCommand(pathResolver, appConfigLoader, new AppContainerFactory()), new DbMigrateCommand(databaseMigrationsApplyService), new UserCreateCommand(new LocalUserCreator(userAdminBootstrap), userAdminCliOptionsParser), new UserListCommand(cliLogger, userAdminBootstrap, new CliDatabaseUrlDescriptor(), userAdminCliOptionsParser));
 	}
 };
 

package/dist/bin.js

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

package/dist/index.d.ts

@@ -223,6 +223,58 @@ interface PersistedRunState {
   connectionInvocations?: ReadonlyArray<ConnectionInvocationRecord>;
 }
 //#endregion
+//#region ../core/src/events/runEvents.d.ts
+type RunEvent = Readonly<{
+  kind: "runCreated";
+  runId: RunId;
+  workflowId: WorkflowId;
+  parent?: ParentExecutionRef;
+  at: string;
+}> | Readonly<{
+  kind: "runSaved";
+  runId: RunId;
+  workflowId: WorkflowId;
+  parent?: ParentExecutionRef;
+  at: string;
+  state: PersistedRunState;
+}> | Readonly<{
+  kind: "nodeQueued";
+  runId: RunId;
+  workflowId: WorkflowId;
+  parent?: ParentExecutionRef;
+  at: string;
+  snapshot: NodeExecutionSnapshot;
+}> | Readonly<{
+  kind: "nodeStarted";
+  runId: RunId;
+  workflowId: WorkflowId;
+  parent?: ParentExecutionRef;
+  at: string;
+  snapshot: NodeExecutionSnapshot;
+}> | Readonly<{
+  kind: "nodeCompleted";
+  runId: RunId;
+  workflowId: WorkflowId;
+  parent?: ParentExecutionRef;
+  at: string;
+  snapshot: NodeExecutionSnapshot;
+}> | Readonly<{
+  kind: "nodeFailed";
+  runId: RunId;
+  workflowId: WorkflowId;
+  parent?: ParentExecutionRef;
+  at: string;
+  snapshot: NodeExecutionSnapshot;
+}>;
+//#endregion
+//#region ../core/src/policies/executionLimits/EngineExecutionLimitsPolicy.d.ts
+interface EngineExecutionLimitsPolicyConfig {
+  readonly defaultMaxNodeActivations: number;
+  readonly hardMaxNodeActivations: number;
+  readonly defaultMaxSubworkflowDepth: number;
+  readonly hardMaxSubworkflowDepth: number;
+}
+//#endregion
 //#region ../core/src/contracts/runtimeTypes.d.ts
 interface NodeExecutionStatePublisher {
   markQueued(args: {
@@ -288,10 +340,10 @@ interface ExecutionContext {
   binary: ExecutionBinaryService;
   getCredential<TSession = unknown>(slotKey: string): Promise<TSession>;
 }
-interface NodeExecutionContext<TConfig extends NodeConfigBase = NodeConfigBase> extends ExecutionContext {
+interface NodeExecutionContext<TConfig$1 extends NodeConfigBase = NodeConfigBase> extends ExecutionContext {
   nodeId: NodeId;
   activationId: NodeActivationId;
-  config: TConfig;
+  config: TConfig$1;
   binary: NodeBinaryAttachmentService;
 }
 //#endregion
@@ -460,15 +512,15 @@ interface WorkflowErrorContext {
   readonly finishedAt: string;
 }
 type WorkflowErrorHandlerSpec = TypeToken<WorkflowErrorHandler> | WorkflowErrorHandler;
-interface NodeErrorHandlerArgs<TConfig extends NodeConfigBase = NodeConfigBase> {
+interface NodeErrorHandlerArgs<TConfig$1 extends NodeConfigBase = NodeConfigBase> {
   readonly kind: "single" | "multi";
   readonly items: Items;
   readonly inputsByPort: Readonly<Record<InputPortKey, Items>> | undefined;
-  readonly ctx: NodeExecutionContext<TConfig>;
+  readonly ctx: NodeExecutionContext<TConfig$1>;
   readonly error: Error;
 }
 interface NodeErrorHandler {
-  handle<TConfig extends NodeConfigBase>(args: NodeErrorHandlerArgs<TConfig>): Promise<NodeOutputs>;
+  handle<TConfig$1 extends NodeConfigBase>(args: NodeErrorHandlerArgs<TConfig$1>): Promise<NodeOutputs>;
 }
 type NodeErrorHandlerSpec = TypeToken<NodeErrorHandler> | NodeErrorHandler;
 //#endregion
@@ -588,58 +640,6 @@ type CredentialType<TPublicConfig extends CredentialJsonRecord = CredentialJsonR
  */
 type AnyCredentialType = CredentialType<any, any, unknown>;
 //#endregion
-//#region ../core/src/events/runEvents.d.ts
-type RunEvent = Readonly<{
-  kind: "runCreated";
-  runId: RunId;
-  workflowId: WorkflowId;
-  parent?: ParentExecutionRef;
-  at: string;
-}> | Readonly<{
-  kind: "runSaved";
-  runId: RunId;
-  workflowId: WorkflowId;
-  parent?: ParentExecutionRef;
-  at: string;
-  state: PersistedRunState;
-}> | Readonly<{
-  kind: "nodeQueued";
-  runId: RunId;
-  workflowId: WorkflowId;
-  parent?: ParentExecutionRef;
-  at: string;
-  snapshot: NodeExecutionSnapshot;
-}> | Readonly<{
-  kind: "nodeStarted";
-  runId: RunId;
-  workflowId: WorkflowId;
-  parent?: ParentExecutionRef;
-  at: string;
-  snapshot: NodeExecutionSnapshot;
-}> | Readonly<{
-  kind: "nodeCompleted";
-  runId: RunId;
-  workflowId: WorkflowId;
-  parent?: ParentExecutionRef;
-  at: string;
-  snapshot: NodeExecutionSnapshot;
-}> | Readonly<{
-  kind: "nodeFailed";
-  runId: RunId;
-  workflowId: WorkflowId;
-  parent?: ParentExecutionRef;
-  at: string;
-  snapshot: NodeExecutionSnapshot;
-}>;
-//#endregion
-//#region ../core/src/policies/executionLimits/EngineExecutionLimitsPolicy.d.ts
-interface EngineExecutionLimitsPolicyConfig {
-  readonly defaultMaxNodeActivations: number;
-  readonly hardMaxNodeActivations: number;
-  readonly defaultMaxSubworkflowDepth: number;
-  readonly hardMaxSubworkflowDepth: number;
-}
-//#endregion
 //#region ../host/src/application/logging/Logger.d.ts
 interface Logger {
   info(message: string, exception?: Error): void;
@@ -832,6 +832,7 @@ interface CodemationPluginContext extends CodemationRegistrationContextBase {
   readonly loggerFactory: LoggerFactory;
 }
 interface CodemationPluginConfig {
+  readonly pluginPackageId?: string;
   readonly credentialTypes?: ReadonlyArray<AnyCredentialType>;
   readonly register?: (context: CodemationPluginContext) => void | Promise<void>;
   readonly sandbox?: CodemationConfig;
@@ -22975,6 +22976,7 @@ type CodemationConsumerConfigResolution = Readonly<{
 }>;
 declare class CodemationConsumerConfigLoader {
   private static readonly importerRegistrationsByTsconfig;
+  private static readonly importerNamespaceVersionByTsconfig;
   private readonly configExportsResolver;
   private readonly configNormalizer;
   private readonly workflowModulePathFinder;
@@ -22996,6 +22998,7 @@ declare class CodemationConsumerConfigLoader {
   private resolveTsconfigPath;
   private getOrCreateImporter;
   private resetImporter;
+  private nextNamespaceVersion;
   private toNamespace;
   private resolveTsxImporterModuleSpecifier;
   private findNearestTsconfig;
@@ -23127,6 +23130,7 @@ type ConsumerOutputBuildSnapshot = Readonly<{
 }>;
 declare class ConsumerOutputBuilder {
   private readonly consumerRoot;
+  private readonly configPathOverride?;
   private static readonly ignoredDirectoryNames;
   private static readonly supportedSourceExtensions;
   private static readonly watchBuildDebounceMs;
@@ -23143,7 +23147,7 @@ declare class ConsumerOutputBuilder {
   private lastIssuedBuildVersion;
   private readonly log;
   private readonly buildOptions;
-  constructor(consumerRoot: string, logOverride?: Logger, buildOptionsOverride?: ConsumerBuildOptions);
+  constructor(consumerRoot: string, logOverride?: Logger, buildOptionsOverride?: ConsumerBuildOptions, configPathOverride?: string | undefined);
   ensureBuilt(): Promise<ConsumerOutputBuildSnapshot>;
   /**
    * Stops the chokidar watcher and clears debounce timers. Safe to call when not watching.
@@ -23208,10 +23212,27 @@ declare class ConsumerOutputBuilder {
   private fileExists;
 }
 //#endregion
+//#region src/build/ConsumerBuildArtifactsPublisher.d.ts
+type ConsumerBuildManifest = Readonly<{
+  buildVersion: string;
+  consumerRoot: string;
+  entryPath: string;
+  manifestPath: string;
+  pluginEntryPath: string;
+  workflowSourcePaths: ReadonlyArray<string>;
+}>;
+declare class ConsumerBuildArtifactsPublisher {
+  publish(snapshot: ConsumerOutputBuildSnapshot, discoveredPlugins: ReadonlyArray<CodemationDiscoveredPluginPackage>): Promise<ConsumerBuildManifest>;
+  private writeDiscoveredPluginsOutput;
+  private writeBuildManifest;
+  private resolvePluginEntry;
+}
+//#endregion
 //#region src/consumer/ConsumerOutputBuilderFactory.d.ts
 declare class ConsumerOutputBuilderFactory {
   create(consumerRoot: string, args?: Readonly<{
     buildOptions?: ConsumerBuildOptions;
+    configPathOverride?: string;
     logger?: Logger;
   }>): ConsumerOutputBuilder;
 }
@@ -23237,8 +23258,10 @@ declare class BuildCommand {
   private readonly cliLogger;
   private readonly pathResolver;
   private readonly consumerOutputBuilderFactory;
+  private readonly pluginDiscovery;
+  private readonly consumerBuildArtifactsPublisher;
   private readonly tsRuntime;
-  constructor(cliLogger: Logger, pathResolver: CliPathResolver, consumerOutputBuilderFactory: ConsumerOutputBuilderFactory, tsRuntime: TypeScriptRuntimeConfigurator);
+  constructor(cliLogger: Logger, pathResolver: CliPathResolver, consumerOutputBuilderFactory: ConsumerOutputBuilderFactory, pluginDiscovery: CodemationPluginDiscovery, consumerBuildArtifactsPublisher: ConsumerBuildArtifactsPublisher, tsRuntime: TypeScriptRuntimeConfigurator);
   execute(consumerRoot: string, buildOptions: ConsumerBuildOptions): Promise<void>;
 }
 //#endregion
@@ -23368,8 +23391,12 @@ declare class ListenPortConflictDescriber {
   private readonly platform;
   constructor(platform?: NodeJS.Platform);
   describeLoopbackPort(port: number): Promise<string | null>;
+  private resolveLoopbackOccupants;
   private readLsofOutput;
   private parseLsofOutput;
+  private readSsOutput;
+  private execFileStdout;
+  private parseSsListenOutput;
 }
 //#endregion
 //#region src/dev/CliDevProxyServer.d.ts
@@ -23407,6 +23434,7 @@ declare class CliDevProxyServer {
   private handleHttpRequest;
   private handleUpgrade;
   private safePathname;
+  private extractOccupyingPids;
   private rejectListenError;
   private broadcastDev;
   private broadcastWorkflowLifecycleToSubscribedRooms;
@@ -23529,6 +23557,7 @@ declare class DevNextHostEnvironmentBuilder {
   buildConsumerUiProxy(args: Readonly<{
     authSecret: string;
     configPathOverride?: string;
+    consumerOutputManifestPath?: string;
     consumerRoot: string;
     developmentServerToken: string;
     nextPort: number;
@@ -23540,6 +23569,7 @@ declare class DevNextHostEnvironmentBuilder {
   build(args: Readonly<{
     authSecret?: string;
     configPathOverride?: string;
+    consumerOutputManifestPath?: string;
     consumerRoot: string;
     developmentServerToken: string;
     nextPort: number;
@@ -23547,6 +23577,7 @@ declare class DevNextHostEnvironmentBuilder {
     websocketPort: number;
     runtimeDevUrl?: string;
   }>): NodeJS.ProcessEnv;
+  private resolvePublicWebsocketPort;
 }
 //#endregion
 //#region src/runtime/ListenPortResolver.d.ts
@@ -23719,6 +23750,9 @@ declare class DevCommand {
   private readonly cliLogger;
   private readonly session;
   private readonly databaseMigrationsApplyService;
+  private readonly consumerOutputBuilderFactory;
+  private readonly pluginDiscovery;
+  private readonly consumerBuildArtifactsPublisher;
   private readonly devBootstrapSummaryFetcher;
   private readonly devCliBannerRenderer;
   private readonly consumerEnvDotenvFilePredicate;
@@ -23728,7 +23762,7 @@ declare class DevCommand {
   private readonly cliDevProxyServerFactory;
   private readonly devRebuildQueueFactory;
   private readonly require;
-  constructor(pathResolver: CliPathResolver, tsRuntime: TypeScriptRuntimeConfigurator, devLockFactory: DevLockFactory, devSourceWatcherFactory: DevSourceWatcherFactory, cliLogger: Logger, session: DevSessionServices, databaseMigrationsApplyService: DatabaseMigrationsApplyService, devBootstrapSummaryFetcher: DevBootstrapSummaryFetcher, devCliBannerRenderer: DevCliBannerRenderer, consumerEnvDotenvFilePredicate: ConsumerEnvDotenvFilePredicate, devTrackedProcessTreeKiller: DevTrackedProcessTreeKiller, nextHostConsumerServerCommandFactory: NextHostConsumerServerCommandFactory, devApiRuntimeFactory: DevApiRuntimeFactory, cliDevProxyServerFactory: CliDevProxyServerFactory, devRebuildQueueFactory: DevRebuildQueueFactory);
+  constructor(pathResolver: CliPathResolver, tsRuntime: TypeScriptRuntimeConfigurator, devLockFactory: DevLockFactory, devSourceWatcherFactory: DevSourceWatcherFactory, cliLogger: Logger, session: DevSessionServices, databaseMigrationsApplyService: DatabaseMigrationsApplyService, consumerOutputBuilderFactory: ConsumerOutputBuilderFactory, pluginDiscovery: CodemationPluginDiscovery, consumerBuildArtifactsPublisher: ConsumerBuildArtifactsPublisher, devBootstrapSummaryFetcher: DevBootstrapSummaryFetcher, devCliBannerRenderer: DevCliBannerRenderer, consumerEnvDotenvFilePredicate: ConsumerEnvDotenvFilePredicate, devTrackedProcessTreeKiller: DevTrackedProcessTreeKiller, nextHostConsumerServerCommandFactory: NextHostConsumerServerCommandFactory, devApiRuntimeFactory: DevApiRuntimeFactory, cliDevProxyServerFactory: CliDevProxyServerFactory, devRebuildQueueFactory: DevRebuildQueueFactory);
   execute(args: Readonly<{
     consumerRoot: string;
     watchFramework?: boolean;
@@ -23758,6 +23792,7 @@ declare class DevCommand {
   private stopLiveProcesses;
   private stopCurrentRuntime;
   private createRuntime;
+  private publishConsumerArtifacts;
   private logPackagedUiDevHintWhenNeeded;
 }
 //#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-C31h2o8w.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.16",
+  "version": "0.0.19",
   "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.16",
-    "@codemation/next-host": "0.0.16"
+    "@codemation/host": "0.0.19",
+    "@codemation/next-host": "0.0.19"
   },
   "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

@@ -3,6 +3,7 @@ import { AppContainerFactory } from "@codemation/host";
 import { logLevelPolicyFactory, ServerLoggerFactory } from "@codemation/host/next/server";
 
 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";
@@ -78,6 +79,8 @@ export class CliProgramFactory {
     );
 
     const buildOptionsParser = new ConsumerBuildOptionsParser();
+    const consumerOutputBuilderFactory = new ConsumerOutputBuilderFactory();
+    const consumerBuildArtifactsPublisher = new ConsumerBuildArtifactsPublisher();
     const devCommand = new DevCommand(
       pathResolver,
       tsRuntime,
@@ -86,6 +89,9 @@ export class CliProgramFactory {
       cliLogger,
       devSessionServices,
       databaseMigrationsApplyService,
+      consumerOutputBuilderFactory,
+      pluginDiscovery,
+      consumerBuildArtifactsPublisher,
       new DevBootstrapSummaryFetcher(),
       new DevCliBannerRenderer(),
       new ConsumerEnvDotenvFilePredicate(),
@@ -97,7 +103,14 @@ export class CliProgramFactory {
     );
     return new CliProgram(
       buildOptionsParser,
-      new BuildCommand(cliLogger, pathResolver, new ConsumerOutputBuilderFactory(), tsRuntime),
+      new BuildCommand(
+        cliLogger,
+        pathResolver,
+        consumerOutputBuilderFactory,
+        pluginDiscovery,
+        consumerBuildArtifactsPublisher,
+        tsRuntime,
+      ),
       devCommand,
       new DevPluginCommand(new PluginDevConfigFactory(), devCommand),
       new ServeWebCommand(

package/src/build/ConsumerBuildArtifactsPublisher.ts

@@ -0,0 +1,82 @@
+import type { CodemationDiscoveredPluginPackage } from "@codemation/host/server";
+import { randomUUID } from "node:crypto";
+import { mkdir, rename, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+
+import type { ConsumerOutputBuildSnapshot } from "../consumer/ConsumerOutputBuilder";
+
+export type ConsumerBuildManifest = Readonly<{
+  buildVersion: string;
+  consumerRoot: string;
+  entryPath: string;
+  manifestPath: string;
+  pluginEntryPath: string;
+  workflowSourcePaths: ReadonlyArray<string>;
+}>;
+
+export class ConsumerBuildArtifactsPublisher {
+  async publish(
+    snapshot: ConsumerOutputBuildSnapshot,
+    discoveredPlugins: ReadonlyArray<CodemationDiscoveredPluginPackage>,
+  ): Promise<ConsumerBuildManifest> {
+    const pluginEntryPath = await this.writeDiscoveredPluginsOutput(snapshot, discoveredPlugins);
+    return await this.writeBuildManifest(snapshot, pluginEntryPath);
+  }
+
+  private async writeDiscoveredPluginsOutput(
+    snapshot: ConsumerOutputBuildSnapshot,
+    discoveredPlugins: ReadonlyArray<CodemationDiscoveredPluginPackage>,
+  ): Promise<string> {
+    const outputPath = path.resolve(snapshot.emitOutputRoot, "plugins.js");
+    await mkdir(path.dirname(outputPath), { recursive: true });
+    const outputLines: string[] = ["const codemationDiscoveredPlugins = [];", ""];
+    discoveredPlugins.forEach((discoveredPlugin: CodemationDiscoveredPluginPackage, index: number) => {
+      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} = pluginModule${index}.default ?? pluginModule${index}.codemationPlugin;`,
+      );
+      outputLines.push(`if (pluginValue${index} && typeof pluginValue${index}.register === "function") {`);
+      outputLines.push(`  codemationDiscoveredPlugins.push(pluginValue${index});`);
+      outputLines.push(
+        `} else if (typeof pluginValue${index} === "function" && pluginValue${index}.prototype && typeof pluginValue${index}.prototype.register === "function") {`,
+      );
+      outputLines.push(`  codemationDiscoveredPlugins.push(new pluginValue${index}());`);
+      outputLines.push("}");
+      outputLines.push("");
+    });
+    outputLines.push("export { codemationDiscoveredPlugins };");
+    outputLines.push("export default codemationDiscoveredPlugins;");
+    outputLines.push("");
+    await writeFile(outputPath, outputLines.join("\n"), "utf8");
+    return outputPath;
+  }
+
+  private async writeBuildManifest(
+    snapshot: ConsumerOutputBuildSnapshot,
+    pluginEntryPath: string,
+  ): Promise<ConsumerBuildManifest> {
+    const manifest: ConsumerBuildManifest = {
+      buildVersion: snapshot.buildVersion,
+      consumerRoot: snapshot.consumerRoot,
+      entryPath: snapshot.outputEntryPath,
+      manifestPath: snapshot.manifestPath,
+      pluginEntryPath,
+      workflowSourcePaths: snapshot.workflowSourcePaths,
+    };
+    await mkdir(path.dirname(snapshot.manifestPath), { recursive: true });
+    const temporaryManifestPath = `${snapshot.manifestPath}.${snapshot.buildVersion}.${randomUUID()}.tmp`;
+    await writeFile(temporaryManifestPath, JSON.stringify(manifest, null, 2), "utf8");
+    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,5 +1,7 @@
+import type { CodemationPluginDiscovery } from "@codemation/host/server";
 import type { Logger } from "@codemation/host/next/server";
 
+import type { ConsumerBuildArtifactsPublisher } from "../build/ConsumerBuildArtifactsPublisher";
 import type { ConsumerOutputBuilderFactory } from "../consumer/ConsumerOutputBuilderFactory";
 import type { ConsumerBuildOptions } from "../consumer/consumerBuildOptions.types";
 import { CliPathResolver } from "../path/CliPathResolver";
@@ -10,6 +12,8 @@ export class BuildCommand {
     private readonly cliLogger: Logger,
     private readonly pathResolver: CliPathResolver,
     private readonly consumerOutputBuilderFactory: ConsumerOutputBuilderFactory,
+    private readonly pluginDiscovery: CodemationPluginDiscovery,
+    private readonly consumerBuildArtifactsPublisher: ConsumerBuildArtifactsPublisher,
     private readonly tsRuntime: TypeScriptRuntimeConfigurator,
   ) {}
 
@@ -18,7 +22,10 @@ export class BuildCommand {
     this.tsRuntime.configure(paths.repoRoot);
     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.consumerBuildArtifactsPublisher.publish(snapshot, discoveredPlugins);
     this.cliLogger.info(`Built consumer output: ${snapshot.outputEntryPath}`);
+    this.cliLogger.info(`Build manifest: ${manifest.manifestPath}`);
     this.cliLogger.info(`Workflow modules emitted: ${snapshot.workflowSourcePaths.length}`);
   }
 }

package/src/commands/DevCommand.ts

@@ -1,9 +1,12 @@
+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";
@@ -35,6 +38,9 @@ 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 consumerEnvDotenvFilePredicate: ConsumerEnvDotenvFilePredicate,
@@ -55,6 +61,7 @@ export class DevCommand {
   ): 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, {
@@ -86,6 +93,12 @@ export class DevCommand {
         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.preparePackagedUiBaseUrlWhenNeeded(prepared, processState);
       proxyServer = await this.startProxyServer(prepared.gatewayPort, uiProxyBase);
@@ -106,6 +119,11 @@ export class DevCommand {
       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();
@@ -416,6 +434,9 @@ export class DevCommand {
     proxyServer.setBuildStatus("building");
     proxyServer.broadcastBuildStarted();
     try {
+      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");
       const runtime = await this.createRuntime(prepared);
@@ -424,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) {
@@ -558,6 +582,16 @@ export class DevCommand {
     });
   }
 
+  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,

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;
@@ -716,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

@@ -8,9 +8,10 @@ export class ConsumerOutputBuilderFactory {
     consumerRoot: string,
     args?: Readonly<{
       buildOptions?: ConsumerBuildOptions;
+      configPathOverride?: string;
       logger?: Logger;
     }>,
   ): ConsumerOutputBuilder {
-    return new ConsumerOutputBuilder(consumerRoot, args?.logger, args?.buildOptions);
+    return new ConsumerOutputBuilder(consumerRoot, args?.logger, args?.buildOptions, args?.configPathOverride);
   }
 }

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/DevNextHostEnvironmentBuilder.ts

@@ -1,3 +1,4 @@
+import path from "node:path";
 import process from "node:process";
 
 import { ConsumerEnvLoader } from "../consumer/ConsumerEnvLoader";
@@ -13,6 +14,7 @@ export class DevNextHostEnvironmentBuilder {
     args: Readonly<{
       authSecret: string;
       configPathOverride?: string;
+      consumerOutputManifestPath?: string;
       consumerRoot: string;
       developmentServerToken: string;
       nextPort: number;
@@ -22,10 +24,12 @@ export class DevNextHostEnvironmentBuilder {
       websocketPort: number;
     }>,
   ): NodeJS.ProcessEnv {
+    const publicWebsocketPort = this.resolvePublicWebsocketPort(args.publicBaseUrl, args.websocketPort);
     return {
       ...this.build({
         authSecret: args.authSecret,
         configPathOverride: args.configPathOverride,
+        consumerOutputManifestPath: args.consumerOutputManifestPath,
         consumerRoot: args.consumerRoot,
         developmentServerToken: args.developmentServerToken,
         nextPort: args.nextPort,
@@ -38,6 +42,8 @@ export class DevNextHostEnvironmentBuilder {
       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),
     };
   }
 
@@ -45,6 +51,7 @@ export class DevNextHostEnvironmentBuilder {
     args: Readonly<{
       authSecret?: string;
       configPathOverride?: string;
+      consumerOutputManifestPath?: string;
       consumerRoot: string;
       developmentServerToken: string;
       nextPort: number;
@@ -54,11 +61,15 @@ export class DevNextHostEnvironmentBuilder {
     }>,
   ): NodeJS.ProcessEnv {
     const merged = this.consumerEnvLoader.mergeConsumerRootIntoProcessEnvironment(args.consumerRoot, process.env);
+    const consumerOutputManifestPath =
+      args.consumerOutputManifestPath ?? path.resolve(args.consumerRoot, ".codemation", "output", "current.json");
     return {
       ...merged,
       PORT: String(args.nextPort),
       CODEMATION_CONSUMER_ROOT: args.consumerRoot,
+      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,
@@ -75,4 +86,17 @@ export class DevNextHostEnvironmentBuilder {
         : {}),
     };
   }
+
+  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.
+    }
+    return fallbackPort;
+  }
 }

package/src/dev/ListenPortConflictDescriber.ts

@@ -18,11 +18,7 @@ export class ListenPortConflictDescriber {
       return null;
     }
 
-    const raw = await this.readLsofOutput(port);
-    if (raw === null) {
-      return null;
-    }
-    const occupants = this.parseLsofOutput(raw);
+    const occupants = await this.resolveLoopbackOccupants(port);
     if (occupants.length === 0) {
       return null;
     }
@@ -32,6 +28,22 @@ export class ListenPortConflictDescriber {
       .join("; ");
   }
 
+  private async resolveLoopbackOccupants(port: number): Promise<ReadonlyArray<PortOccupant>> {
+    const lsofRaw = await this.readLsofOutput(port);
+    const fromLsof = lsofRaw !== null ? this.parseLsofOutput(lsofRaw) : [];
+    if (fromLsof.length > 0) {
+      return fromLsof;
+    }
+    if (this.platform !== "linux") {
+      return [];
+    }
+    const ssRaw = await this.readSsOutput(port);
+    if (ssRaw === null) {
+      return [];
+    }
+    return this.parseSsListenOutput(ssRaw, port);
+  }
+
   private async readLsofOutput(port: number): Promise<string | null> {
     try {
       return await new Promise<string>((resolve, reject) => {
@@ -80,4 +92,53 @@ export class ListenPortConflictDescriber {
 
     return occupants;
   }
+
+  private async readSsOutput(port: number): Promise<string | null> {
+    const filtered = await this.execFileStdout("ss", ["-lntp", `sport = :${port}`]);
+    if (filtered !== null && filtered.trim().length > 0) {
+      return filtered;
+    }
+    return this.execFileStdout("ss", ["-lntp"]);
+  }
+
+  private async execFileStdout(command: string, args: readonly string[]): Promise<string | null> {
+    try {
+      return await new Promise<string>((resolve, reject) => {
+        execFile(command, [...args], (error, stdout) => {
+          if (error) {
+            reject(error);
+            return;
+          }
+          resolve(stdout);
+        });
+      });
+    } catch {
+      return null;
+    }
+  }
+
+  private parseSsListenOutput(raw: string, port: number): ReadonlyArray<PortOccupant> {
+    const occupants: PortOccupant[] = [];
+    const portSuffix = `:${port}`;
+    for (const line of raw.split("\n")) {
+      if (!line.includes("LISTEN") || !line.includes(portSuffix)) {
+        continue;
+      }
+      const pidMatch = line.match(/pid=(\d+)/);
+      if (!pidMatch) {
+        continue;
+      }
+      const pid = Number.parseInt(pidMatch[1] ?? "0", 10);
+      const cmdMatch = line.match(/users:\(\("([^"]*)"/);
+      const command = cmdMatch?.[1] ?? "unknown";
+      const localAddrMatch = line.match(/\s+(\S+:\d+|\[[^\]]+\]:\d+)\s+/);
+      const endpoint = localAddrMatch?.[1] ?? `tcp:${String(port)}`;
+      occupants.push({
+        pid,
+        command,
+        endpoint,
+      });
+    }
+    return occupants;
+  }
 }