@kubb/cli 4.22.0 → 4.22.1

package/dist/{generate-BJyvkuLI.cjs → generate-BxSL_NKj.cjs}

@@ -1,5 +1,6 @@
 const require_chunk = require('./chunk-C1_xRkKa.cjs');
-const require_package = require('./package-Cnl_fuIC.cjs');
+const require_package = require('./package-Cmbk_MZB.cjs');
+const require_getCosmiConfig = require('./getCosmiConfig-Co29x0Wv.cjs');
 let citty = require("citty");
 let node_path = require("node:path");
 node_path = require_chunk.__toESM(node_path);
@@ -21,12 +22,6 @@ let seedrandom = require("seedrandom");
 seedrandom = require_chunk.__toESM(seedrandom);
 let node_stream = require("node:stream");
 let _kubb_core_fs = require("@kubb/core/fs");
-let node_crypto = require("node:crypto");
-let string_argv = require("string-argv");
-let cosmiconfig = require("cosmiconfig");
-let jiti = require("jiti");
-let node_fs = require("node:fs");
-let node_http = require("node:http");
 
 //#region src/utils/formatMsWithColor.ts
 /**
@@ -1135,626 +1130,17 @@ async function setupLogger(context, { logLevel }) {
 	return cleanup;
 }
 
-//#endregion
-//#region src/utils/detectFormatter.ts
-/**
-* Check if a formatter command is available in the system.
-*
-* @param formatter - The formatter to check ('biome', 'prettier', or 'oxfmt')
-* @returns Promise that resolves to true if the formatter is available, false otherwise
-*
-* @remarks
-* This function checks availability by running `<formatter> --version` command.
-* All supported formatters (biome, prettier, oxfmt) implement the --version flag.
-*/
-async function isFormatterAvailable(formatter) {
-	try {
-		await (0, execa.execaCommand)(`${formatter} --version`, { stdio: "ignore" });
-		return true;
-	} catch {
-		return false;
-	}
-}
-/**
-* Detect which formatter is available in the system.
-*
-* @returns Promise that resolves to the first available formatter or undefined if none are found
-*
-* @remarks
-* Checks in order of preference: biome, oxfmt, prettier.
-* Uses the `--version` flag to detect if each formatter command is available.
-* This is a reliable method as all supported formatters implement this flag.
-*
-* @example
-* ```typescript
-* const formatter = await detectFormatter()
-* if (formatter) {
-*   console.log(`Using ${formatter} for formatting`)
-* } else {
-*   console.log('No formatter found')
-* }
-* ```
-*/
-async function detectFormatter() {
-	for (const formatter of [
-		"biome",
-		"oxfmt",
-		"prettier"
-	]) if (await isFormatterAvailable(formatter)) return formatter;
-}
-
-//#endregion
-//#region src/utils/detectLinter.ts
-/**
-* Check if a linter command is available in the system.
-*
-* @param linter - The linter to check ('biome', 'oxlint', or 'eslint')
-* @returns Promise that resolves to true if the linter is available, false otherwise
-*
-* @remarks
-* This function checks availability by running `<linter> --version` command.
-* All supported linters (biome, oxlint, eslint) implement the --version flag.
-*/
-async function isLinterAvailable(linter) {
-	try {
-		await (0, execa.execaCommand)(`${linter} --version`, { stdio: "ignore" });
-		return true;
-	} catch {
-		return false;
-	}
-}
-/**
-* Detect which linter is available in the system.
-*
-* @returns Promise that resolves to the first available linter or undefined if none are found
-*
-* @remarks
-* Checks in order of preference: biome, oxlint, eslint.
-* Uses the `--version` flag to detect if each linter command is available.
-* This is a reliable method as all supported linters implement this flag.
-*
-* @example
-* ```typescript
-* const linter = await detectLinter()
-* if (linter) {
-*   console.log(`Using ${linter} for linting`)
-* } else {
-*   console.log('No linter found')
-* }
-* ```
-*/
-async function detectLinter() {
-	for (const linter of [
-		"biome",
-		"oxlint",
-		"eslint"
-	]) if (await isLinterAvailable(linter)) return linter;
-}
-
-//#endregion
-//#region src/utils/executeHooks.ts
-async function executeHooks({ hooks, events }) {
-	const commands = Array.isArray(hooks.done) ? hooks.done : [hooks.done].filter(Boolean);
-	for (const command$1 of commands) {
-		const [cmd, ...args] = [...(0, string_argv.parseArgsStringToArgv)(command$1)];
-		if (!cmd) continue;
-		const hookId = (0, node_crypto.createHash)("sha256").update(command$1).digest("hex");
-		await events.emit("hook:start", {
-			id: hookId,
-			command: cmd,
-			args
-		});
-		await events.onOnce("hook:end", async ({ success, error }) => {
-			if (!success) throw error;
-			await events.emit("success", `${picocolors.default.dim(command$1)} successfully executed`);
-		});
-	}
-}
-
-//#endregion
-//#region src/utils/formatters.ts
-const formatters = {
-	prettier: {
-		command: "prettier",
-		args: (outputPath) => [
-			"--ignore-unknown",
-			"--write",
-			outputPath
-		],
-		errorMessage: "Prettier not found"
-	},
-	biome: {
-		command: "biome",
-		args: (outputPath) => [
-			"format",
-			"--write",
-			outputPath
-		],
-		errorMessage: "Biome not found"
-	},
-	oxfmt: {
-		command: "oxfmt",
-		args: (outputPath) => [outputPath],
-		errorMessage: "Oxfmt not found"
-	}
-};
-
-//#endregion
-//#region src/runners/generate.ts
-async function generate({ input, config: userConfig, events, logLevel }) {
-	const inputPath = input ?? ("path" in userConfig.input ? userConfig.input.path : void 0);
-	const hrStart = node_process.default.hrtime();
-	const config = {
-		...userConfig,
-		root: userConfig.root || node_process.default.cwd(),
-		input: inputPath ? {
-			...userConfig.input,
-			path: inputPath
-		} : userConfig.input,
-		output: {
-			write: true,
-			barrelType: "named",
-			extension: { ".ts": ".ts" },
-			format: "prettier",
-			...userConfig.output
-		}
-	};
-	await events.emit("generation:start", config);
-	await events.emit("info", config.name ? `Setup generation ${picocolors.default.bold(config.name)}` : "Setup generation", inputPath);
-	const { sources, fabric, pluginManager } = await (0, _kubb_core.setup)({
-		config,
-		events
-	});
-	await events.emit("info", config.name ? `Build generation ${picocolors.default.bold(config.name)}` : "Build generation", inputPath);
-	const { files, failedPlugins, pluginTimings, error } = await (0, _kubb_core.safeBuild)({
-		config,
-		events
-	}, {
-		pluginManager,
-		fabric,
-		events,
-		sources
-	});
-	await events.emit("info", "Load summary");
-	if (failedPlugins.size > 0 || error) {
-		[error, ...Array.from(failedPlugins).filter((it) => it.error).map((it) => it.error)].filter(Boolean).forEach((err) => {
-			events.emit("error", err);
-		});
-		await events.emit("generation:end", config, files, sources);
-		await events.emit("generation:summary", config, {
-			failedPlugins,
-			filesCreated: files.length,
-			status: failedPlugins.size > 0 || error ? "failed" : "success",
-			hrStart,
-			pluginTimings: logLevel >= _kubb_core.LogLevel.verbose ? pluginTimings : void 0
-		});
-		node_process.default.exit(1);
-	}
-	await events.emit("success", "Generation successfully", inputPath);
-	await events.emit("generation:end", config, files, sources);
-	if (config.output.format) {
-		await events.emit("format:start");
-		let formatter = config.output.format;
-		if (formatter === "auto") {
-			const detectedFormatter = await detectFormatter();
-			if (!detectedFormatter) await events.emit("warn", "No formatter found (biome, prettier, or oxfmt). Skipping formatting.");
-			else {
-				formatter = detectedFormatter;
-				await events.emit("info", `Auto-detected formatter: ${picocolors.default.dim(formatter)}`);
-			}
-		}
-		if (formatter && formatter !== "auto" && formatter in formatters) {
-			const formatterConfig = formatters[formatter];
-			const outputPath = node_path.default.resolve(config.root, config.output.path);
-			try {
-				const hookId = (0, node_crypto.createHash)("sha256").update([config.name, formatter].filter(Boolean).join("-")).digest("hex");
-				await events.emit("hook:start", {
-					id: hookId,
-					command: formatterConfig.command,
-					args: formatterConfig.args(outputPath)
-				});
-				await events.onOnce("hook:end", async ({ success, error: error$1 }) => {
-					if (!success) throw error$1;
-					await events.emit("success", [
-						`Formatting with ${picocolors.default.dim(formatter)}`,
-						logLevel >= _kubb_core.LogLevel.info ? `on ${picocolors.default.dim(outputPath)}` : void 0,
-						"successfully"
-					].filter(Boolean).join(" "));
-				});
-			} catch (caughtError) {
-				const error$1 = new Error(formatterConfig.errorMessage);
-				error$1.cause = caughtError;
-				await events.emit("error", error$1);
-			}
-		}
-		await events.emit("format:end");
-	}
-	if (config.output.lint) {
-		await events.emit("lint:start");
-		let linter = config.output.lint;
-		if (linter === "auto") {
-			const detectedLinter = await detectLinter();
-			if (!detectedLinter) await events.emit("warn", "No linter found (biome, oxlint, or eslint). Skipping linting.");
-			else {
-				linter = detectedLinter;
-				await events.emit("info", `Auto-detected linter: ${picocolors.default.dim(linter)}`);
-			}
-		}
-		if (linter && linter !== "auto") {
-			await events.emit("info", [`Linting with ${picocolors.default.dim(linter)}`, logLevel >= _kubb_core.LogLevel.info ? `on ${picocolors.default.dim(node_path.default.resolve(config.root, config.output.path))}` : void 0].filter(Boolean).join(" "));
-			if (linter === "eslint") try {
-				const hookId = (0, node_crypto.createHash)("sha256").update([config.name, linter].filter(Boolean).join("-")).digest("hex");
-				await events.emit("hook:start", {
-					id: hookId,
-					command: "eslint",
-					args: [node_path.default.resolve(config.root, config.output.path), "--fix"]
-				});
-				await events.onOnce("hook:end", async ({ success, error: error$1 }) => {
-					if (!success) throw error$1;
-					await events.emit("success", [
-						`Linted with ${picocolors.default.dim(linter)}`,
-						logLevel >= _kubb_core.LogLevel.info ? `on ${picocolors.default.dim(node_path.default.resolve(config.root, config.output.path))}` : void 0,
-						"successfully"
-					].filter(Boolean).join(" "));
-				});
-			} catch (caughtError) {
-				const error$1 = /* @__PURE__ */ new Error("Eslint not found");
-				error$1.cause = caughtError;
-				await events.emit("error", error$1);
-			}
-			if (linter === "biome") try {
-				const hookId = (0, node_crypto.createHash)("sha256").update([config.name, linter].filter(Boolean).join("-")).digest("hex");
-				await events.emit("hook:start", {
-					id: hookId,
-					command: "biome",
-					args: [
-						"lint",
-						"--fix",
-						node_path.default.resolve(config.root, config.output.path)
-					]
-				});
-				await events.onOnce("hook:end", async ({ success, error: error$1 }) => {
-					if (!success) throw error$1;
-					await events.emit("success", [
-						`Linted with ${picocolors.default.dim(linter)}`,
-						logLevel >= _kubb_core.LogLevel.info ? `on ${picocolors.default.dim(node_path.default.resolve(config.root, config.output.path))}` : void 0,
-						"successfully"
-					].filter(Boolean).join(" "));
-				});
-			} catch (caughtError) {
-				const error$1 = /* @__PURE__ */ new Error("Biome not found");
-				error$1.cause = caughtError;
-				await events.emit("error", error$1);
-			}
-			if (linter === "oxlint") try {
-				const hookId = (0, node_crypto.createHash)("sha256").update([config.name, linter].filter(Boolean).join("-")).digest("hex");
-				await events.emit("hook:start", {
-					id: hookId,
-					command: "oxlint",
-					args: ["--fix", node_path.default.resolve(config.root, config.output.path)]
-				});
-				await events.onOnce("hook:end", async ({ success, error: error$1 }) => {
-					if (!success) throw error$1;
-					await events.emit("success", [
-						`Linted with ${picocolors.default.dim(linter)}`,
-						logLevel >= _kubb_core.LogLevel.info ? `on ${picocolors.default.dim(node_path.default.resolve(config.root, config.output.path))}` : void 0,
-						"successfully"
-					].filter(Boolean).join(" "));
-				});
-			} catch (caughtError) {
-				const error$1 = /* @__PURE__ */ new Error("Oxlint not found");
-				error$1.cause = caughtError;
-				await events.emit("error", error$1);
-			}
-		}
-		await events.emit("lint:end");
-	}
-	if (config.hooks) {
-		await events.emit("hooks:start");
-		await executeHooks({
-			hooks: config.hooks,
-			events
-		});
-		await events.emit("hooks:end");
-	}
-	await events.emit("generation:summary", config, {
-		failedPlugins,
-		filesCreated: files.length,
-		status: failedPlugins.size > 0 || error ? "failed" : "success",
-		hrStart,
-		pluginTimings
-	});
-}
-
-//#endregion
-//#region src/utils/getPlugins.ts
-function isJSONPlugins(plugins) {
-	return !!plugins?.some((plugin) => {
-		return Array.isArray(plugin) && typeof plugin?.at(0) === "string";
-	});
-}
-function isObjectPlugins(plugins) {
-	return plugins instanceof Object && !Array.isArray(plugins);
-}
-function getPlugins(plugins) {
-	if (isObjectPlugins(plugins)) throw new Error("Object plugins are not supported anymore, best to use http://kubb.dev/getting-started/configure#json");
-	if (isJSONPlugins(plugins)) throw new Error("JSON plugins are not supported anymore, best to use http://kubb.dev/getting-started/configure#json");
-	return Promise.resolve(plugins);
-}
-
-//#endregion
-//#region src/utils/getConfigs.ts
-/**
-* Converting UserConfig to Config Array without a change in the object beside the JSON convert.
-*/
-async function getConfigs(result, args) {
-	const config = result?.config;
-	let kubbUserConfig = Promise.resolve(config);
-	if (typeof config === "function") {
-		const possiblePromise = config(args);
-		if ((0, _kubb_core_utils.isPromise)(possiblePromise)) kubbUserConfig = possiblePromise;
-		kubbUserConfig = Promise.resolve(possiblePromise);
-	}
-	let JSONConfig = await kubbUserConfig;
-	if (!Array.isArray(JSONConfig)) JSONConfig = [JSONConfig];
-	const results = [];
-	for (const item of JSONConfig) {
-		const plugins = item.plugins ? await getPlugins(item.plugins) : void 0;
-		results.push({
-			...item,
-			plugins
-		});
-	}
-	return results;
-}
-
-//#endregion
-//#region src/utils/getCosmiConfig.ts
-const tsLoader = async (configFile) => {
-	return await (0, jiti.createJiti)(configFile, {
-		jsx: {
-			runtime: "automatic",
-			importSource: "@kubb/react-fabric"
-		},
-		sourceMaps: true,
-		interopDefault: true
-	}).import(configFile, { default: true });
-};
-async function getCosmiConfig(moduleName, config) {
-	let result;
-	const searchPlaces = [
-		"package.json",
-		`.${moduleName}rc`,
-		`.${moduleName}rc.json`,
-		`.${moduleName}rc.yaml`,
-		`.${moduleName}rc.yml`,
-		`.${moduleName}rc.ts`,
-		`.${moduleName}rc.js`,
-		`.${moduleName}rc.mjs`,
-		`.${moduleName}rc.cjs`,
-		`${moduleName}.config.ts`,
-		`${moduleName}.config.js`,
-		`${moduleName}.config.mjs`,
-		`${moduleName}.config.cjs`
-	];
-	const explorer = (0, cosmiconfig.cosmiconfig)(moduleName, {
-		cache: false,
-		searchPlaces: [
-			...searchPlaces.map((searchPlace) => {
-				return `.config/${searchPlace}`;
-			}),
-			...searchPlaces.map((searchPlace) => {
-				return `configs/${searchPlace}`;
-			}),
-			...searchPlaces
-		],
-		loaders: { ".ts": tsLoader }
-	});
-	try {
-		result = config ? await explorer.load(config) : await explorer.search();
-	} catch (error) {
-		throw new Error("Config failed loading", { cause: error });
-	}
-	if (result?.isEmpty || !result || !result.config) throw new Error("Config not defined, create a kubb.config.js or pass through your config with the option --config");
-	return result;
-}
-
-//#endregion
-//#region src/loggers/streamLogger.ts
-/**
-* Stream logger for SSE (Server-Sent Events) streaming
-* Sends Kubb events to HTTP client via SSE protocol
-*/
-function createStreamLogger(res) {
-	return (0, _kubb_core.defineLogger)({
-		name: "stream",
-		install(context, options) {
-			const logLevel = options?.logLevel || _kubb_core.LogLevel.info;
-			const state = { res };
-			function send(type, ...data) {
-				if (!state.res.destroyed) state.res.write(`data: ${JSON.stringify({
-					type,
-					data
-				})}\n\n`);
-			}
-			context.on("plugin:start", (plugin) => {
-				send("plugin:start", { name: plugin.name });
-			});
-			context.on("plugin:end", (plugin, { duration, success }) => {
-				send("plugin:end", { name: plugin.name }, {
-					duration,
-					success
-				});
-			});
-			context.on("files:processing:start", (files) => {
-				send("files:processing:start", { total: files.length });
-			});
-			context.on("file:processing:update", ({ file, processed, total, percentage, config }) => {
-				send("file:processing:update", {
-					file: file.path ? (0, node_path.relative)(config.root, file.path) : file.baseName || "unknown",
-					processed,
-					total,
-					percentage
-				});
-			});
-			context.on("files:processing:end", (files) => {
-				send("files:processing:end", { total: files.length });
-			});
-			context.on("info", (message, info) => {
-				if (logLevel <= _kubb_core.LogLevel.silent) return;
-				send("info", message, info);
-			});
-			context.on("success", (message, info) => {
-				if (logLevel <= _kubb_core.LogLevel.silent) return;
-				send("success", message, info);
-			});
-			context.on("warn", (message, info) => {
-				if (logLevel < _kubb_core.LogLevel.warn) return;
-				send("warn", message, info);
-			});
-			context.on("error", (error) => {
-				send("error", {
-					message: error.message,
-					stack: logLevel >= _kubb_core.LogLevel.debug ? error.stack : void 0
-				});
-			});
-			context.on("generation:start", (config) => {
-				send("generation:start", {
-					name: config.name,
-					plugins: config.plugins?.length || 0
-				});
-			});
-			context.on("generation:end", (config, files, sources) => {
-				send("generation:end", config, files, Object.fromEntries(sources));
-			});
-		}
-	});
-}
-
-//#endregion
-//#region src/utils/streamServer.ts
-async function startStreamServer({ port, host, configPath, config, input, args }) {
-	const server = (0, node_http.createServer)(async (req, res) => {
-		res.setHeader("Access-Control-Allow-Origin", "*");
-		res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
-		res.setHeader("Access-Control-Allow-Headers", "Content-Type");
-		if (req.method === "OPTIONS") {
-			res.writeHead(204);
-			res.end();
-			return;
-		}
-		if (req.url === "/api/health" && req.method === "GET") {
-			res.writeHead(200, { "Content-Type": "application/json" });
-			const body = {
-				status: "ok",
-				version: require_package.version,
-				configPath: node_path.default.relative(node_process.default.cwd(), configPath)
-			};
-			res.end(JSON.stringify(body));
-			return;
-		}
-		if (req.url === "/api/info" && req.method === "GET") {
-			res.writeHead(200, { "Content-Type": "application/json" });
-			let specContent;
-			if (config && "path" in config.input) {
-				const specPath = node_path.default.resolve(node_process.default.cwd(), config.root, config.input.path);
-				try {
-					specContent = (0, node_fs.readFileSync)(specPath, "utf-8");
-				} catch {}
-			}
-			const body = {
-				version: require_package.version,
-				configPath: node_path.default.relative(node_process.default.cwd(), configPath),
-				spec: specContent,
-				config: {
-					name: config.name,
-					root: config.root,
-					input: { path: "path" in config.input ? config.input.path : void 0 },
-					output: {
-						path: config.output.path,
-						write: config.output.write,
-						extension: config.output.extension,
-						barrelType: config.output.barrelType
-					},
-					plugins: config.plugins?.map((plugin) => ({
-						name: `@kubb/${plugin.name}`,
-						options: (0, _kubb_core_utils.serializePluginOptions)(plugin.options)
-					}))
-				}
-			};
-			res.end(JSON.stringify(body));
-			return;
-		}
-		if (req.url === "/api/stream" && req.method === "POST") {
-			await handleGenerate(res, config, input, args);
-			return;
-		}
-		res.writeHead(404, { "Content-Type": "application/json" });
-		res.end(JSON.stringify({ error: "Not found" }));
-	});
-	server.listen(port, host, () => {
-		const address = server.address();
-		const serverUrl = `http://${host}:${typeof address === "object" && address ? address.port : port}`;
-		_clack_prompts.log.success(picocolors.default.green(`Stream server started on ${picocolors.default.bold(serverUrl)}`));
-		_clack_prompts.log.info(picocolors.default.dim(`Config: ${node_path.default.relative(node_process.default.cwd(), configPath)}`));
-		_clack_prompts.log.info(picocolors.default.dim(`Connect: ${serverUrl}/api/info`));
-		_clack_prompts.log.info(picocolors.default.dim(`Stream: ${serverUrl}/api/stream`));
-		_clack_prompts.log.info(picocolors.default.dim(`Health: ${serverUrl}/api/health`));
-		_clack_prompts.log.step(picocolors.default.yellow("Waiting for requests... (Press Ctrl+C to stop)"));
-	});
-	node_process.default.on("SIGINT", () => {
-		_clack_prompts.log.info("Shutting down stream server...");
-		server.close(() => {
-			_clack_prompts.log.success("Server stopped");
-			node_process.default.exit(0);
-		});
-	});
-}
-async function handleGenerate(res, config, input, args) {
-	const events = new _kubb_core_utils.AsyncEventEmitter();
-	const logLevel = _kubb_core.LogLevel[args.logLevel] || 3;
-	res.writeHead(200, {
-		"Content-Type": "text/event-stream",
-		"Cache-Control": "no-cache",
-		Connection: "keep-alive"
-	});
-	function send(type, ...data) {
-		const streamEvent = {
-			type,
-			data
-		};
-		res.write(`data: ${JSON.stringify(streamEvent)}\n\n`);
-	}
-	await createStreamLogger(res).install(events, { logLevel });
-	try {
-		await generate({
-			input,
-			config,
-			logLevel,
-			events
-		});
-		send("lifecycle:end");
-	} catch (error) {
-		send("error", {
-			message: error instanceof Error ? error.message : "Unknown error",
-			stack: error instanceof Error ? error.stack : void 0
-		});
-	} finally {
-		res.end();
-	}
-}
-
 //#endregion
 //#region src/utils/watcher.ts
-async function startWatcher(path$4, cb) {
+async function startWatcher(path$2, cb) {
 	const { watch } = await import("chokidar");
-	watch(path$4, {
+	watch(path$2, {
 		ignorePermissionErrors: true,
 		ignored: "**/{.git,node_modules}/**"
 	}).on("all", async (type, file) => {
 		console.log(picocolors.default.yellow(picocolors.default.bold(`Change detected: ${type} ${file}`)));
 		try {
-			await cb(path$4);
+			await cb(path$2);
 		} catch (_e) {
 			console.log(picocolors.default.red("Watcher failed"));
 		}
@@ -1805,21 +1191,6 @@ const command = (0, citty.defineCommand)({
 			alias: "s",
 			default: false
 		},
-		stream: {
-			type: "boolean",
-			description: "Start HTTP server with SSE streaming",
-			default: false
-		},
-		port: {
-			type: "string",
-			description: "Port for stream server (requires --stream). If not specified, an available port is automatically selected.",
-			alias: "p"
-		},
-		host: {
-			type: "string",
-			description: "Host for stream server (requires --stream)",
-			default: "localhost"
-		},
 		help: {
 			type: "boolean",
 			description: "Show help",
@@ -1843,22 +1214,8 @@ const command = (0, citty.defineCommand)({
 			if ((0, semver.lt)(require_package.version, latestVersion)) await events.emit("version:new", require_package.version, latestVersion);
 		});
 		try {
-			const result = await getCosmiConfig("kubb", args.config);
-			const configs = await getConfigs(result, args);
-			if (args.stream) {
-				if (configs.length > 1) _clack_prompts.log.warn(picocolors.default.yellow("Stream mode only supports a single configuration. Only the first config will be used."));
-				const port = args.port ? Number.parseInt(args.port, 10) : 0;
-				const host = args.host;
-				await startStreamServer({
-					port,
-					host,
-					configPath: result.filepath,
-					config: configs[0],
-					input,
-					args
-				});
-				return;
-			}
+			const result = await require_getCosmiConfig.getCosmiConfig("kubb", args.config);
+			const configs = await require_getCosmiConfig.getConfigs(result, args);
 			await events.emit("config:start");
 			await events.emit("info", "Config loaded", node_path.default.relative(node_process.cwd(), result.filepath));
 			await events.emit("success", "Config loaded successfully", node_path.default.relative(node_process.cwd(), result.filepath));
@@ -1868,7 +1225,7 @@ const command = (0, citty.defineCommand)({
 				return async () => {
 					if ((0, _kubb_core.isInputPath)(config) && args.watch) {
 						await startWatcher([input || config.input.path], async (paths) => {
-							await generate({
+							await require_getCosmiConfig.generate({
 								input,
 								config,
 								logLevel,
@@ -1878,7 +1235,7 @@ const command = (0, citty.defineCommand)({
 						});
 						return;
 					}
-					await generate({
+					await require_getCosmiConfig.generate({
 						input,
 						config,
 						logLevel,
@@ -1898,4 +1255,4 @@ var generate_default = command;
 
 //#endregion
 exports.default = generate_default;
-//# sourceMappingURL=generate-BJyvkuLI.cjs.map
+//# sourceMappingURL=generate-BxSL_NKj.cjs.map