@kubb/cli 5.9.2 → 5.9.4

package/dist/index.js

@@ -1,8 +1,16 @@
-import "./rolldown-runtime-CRm0XQPb.js";
-import { r as version, t as isDisabled } from "./Telemetry-DER8LIO5.js";
+import { t as __name } from "./rolldown-runtime-CRm0XQPb.js";
+import { c as getErrorMessage, r as version, t as isDisabled } from "./Telemetry-E_BBHmnT.js";
+import { S as initDefaults, a as logInfo, b as KUBB_CONFIG_FILENAME, d as logWarn, i as logError, l as logStep, o as logIntro, r as logBlock, s as logOutro, t as createSpinner, v as findConfigFile, x as KUBB_PACKAGE_NAME } from "./output-DS5hyqwL.js";
+import { a as isOutdated, i as installSpec, n as fetchRegistryIndex, o as registryUrl, r as incompatibility, s as toRegistryId, t as fetchRegistryDetail } from "./registry-CSXUuuCy.js";
 import { styleText } from "node:util";
 import dryrun, { pluginId as dryRunId } from "@gunshi/plugin-dryrun";
 import { cli, define, defineWithTypes } from "gunshi";
+import process$1 from "node:process";
+import { x } from "tinyexec";
+import path from "node:path";
+import * as clack from "@clack/prompts";
+import fs from "node:fs";
+import { readInstalledPackages } from "@kubb/core";
 //#region src/commands/shared.ts
 const configArg = { config: {
 	type: "string",
@@ -64,43 +72,6 @@ const studioPermissionArgs = {
 	}
 };
 //#endregion
-//#region src/commands/add.ts
-const command$13 = define({
-	name: "add",
-	description: "Install a plugin, adapter, or parser from the Kubb registry at its reviewed version. A plugin is added to kubb.config.ts, an adapter or parser prints the code to add. Reads KUBB_REGISTRY to use another registry.",
-	examples: [
-		"kubb add plugin-zod",
-		"kubb add kubb-labs/plugin-react-query",
-		"kubb add acme/plugin-x --yes",
-		"kubb add plugin-zod --no-install"
-	].join("\n"),
-	toKebab: true,
-	args: {
-		id: {
-			type: "positional",
-			description: "Registry id: owner/slug, or a slug for an official extension",
-			required: true
-		},
-		...configArg,
-		...yesArg,
-		install: {
-			type: "boolean",
-			description: "Install the package. Pass --no-install to only edit the config",
-			negatable: true,
-			default: true
-		}
-	},
-	async run({ values }) {
-		const { run } = await import("./run-8HrdMihy.js");
-		await run({
-			id: values.id,
-			configPath: values.config,
-			yes: values.yes,
-			install: values.install
-		});
-	}
-});
-//#endregion
 //#region src/commands/generate.ts
 const REPORTER_NAMES = [
 	"cli",
@@ -124,7 +95,7 @@ function resolveLogLevel({ verbose, silent, logLevel }) {
 	if (silent) return "silent";
 	return logLevel;
 }
-const command$12 = defineWithTypes()({
+const command$13 = defineWithTypes()({
 	name: "generate",
 	description: "Generate TypeScript types, API clients, React Query hooks, Zod schemas, and more from an OpenAPI specification. Reads kubb.config.ts by default. Pass an OpenAPI file path as the first argument to override the input without editing the config.",
 	examples: [
@@ -174,7 +145,7 @@ const command$12 = defineWithTypes()({
 	async run(ctx) {
 		const { values } = ctx;
 		const logLevel = resolveLogLevel(values);
-		const { run } = await import("./run-BcMMYk7G.js");
+		const { run } = await import("./run-BPD5Vaon.js");
 		await run({
 			input: values.input,
 			configPath: values.config,
@@ -186,71 +157,9 @@ const command$12 = defineWithTypes()({
 	}
 });
 //#endregion
-//#region src/commands/init.ts
-const command$11 = defineWithTypes()({
-	name: "init",
-	description: "Scaffold a kubb.config.ts and install plugins for code generation from an OpenAPI spec. Run without flags for interactive setup, or pass --input, --output, and --plugins to skip the prompts.",
-	examples: [
-		"kubb init",
-		"kubb init --yes",
-		"kubb init --input ./openapi.yaml --output ./src/gen --plugins plugin-ts,plugin-zod",
-		"kubb init --plugins plugin-ts,plugin-axios,plugin-react-query",
-		"kubb init --yes --dry-run"
-	].join("\n"),
-	toKebab: true,
-	args: {
-		yes: {
-			type: "boolean",
-			description: "Skip prompts and use default options",
-			short: "y",
-			default: false
-		},
-		input: {
-			type: "string",
-			description: "Path to the OpenAPI specification",
-			short: "i",
-			metavar: "path"
-		},
-		output: {
-			type: "string",
-			description: "Output directory for generated files",
-			short: "o",
-			metavar: "path"
-		},
-		plugins: {
-			type: "string",
-			description: "Comma-separated Kubb registry ids of the plugins to add, the same ids `kubb add` takes (plugin-ts, plugin-zod, acme/plugin-x)",
-			metavar: "plugin-ts,plugin-zod,..."
-		}
-	},
-	async run(ctx) {
-		const { values } = ctx;
-		const { run } = await import("./run-CJHsZZB8.js");
-		await run({
-			yes: values.yes,
-			version,
-			input: values.input,
-			output: values.output,
-			plugins: values.plugins,
-			dryRun: ctx.extensions[dryRunId]
-		});
-	}
-});
-//#endregion
-//#region src/commands/list.ts
-const command$10 = define({
-	name: "list",
-	description: "List the installed Kubb extensions: their registry id, package, installed version, the version the Kubb registry pins, and whether an update exists.",
-	examples: "kubb list",
-	async run() {
-		const { run } = await import("./run-BYff_byB.js");
-		await run();
-	}
-});
-//#endregion
 //#region src/commands/mcp.ts
 /** The runner is imported when the command runs, so listing `kubb --help` never loads `@kubb/mcp`. */
-const command$9 = define({
+const command$12 = define({
 	name: "mcp",
 	description: "Start a Model Context Protocol (MCP) server that exposes Kubb code generation as tools for AI assistants. Once running, configure your AI client (Claude, Cursor, Windsurf, etc.) to connect to it — the assistant can then call kubb generate directly without leaving the chat.",
 	examples: [
@@ -260,13 +169,29 @@ const command$9 = define({
 	].join("\n"),
 	rendering: { header: null },
 	async run() {
-		const { run } = await import("./run-KLPSFEv-.js");
+		const { run } = await import("./run-CecrPSop.js");
 		await run();
 	}
 });
 //#endregion
+//#region src/commands/studio/studioCommand.ts
+/**
+* Defines a `kubb studio` subcommand. The runner, and with it `@kubb/studio`, loads only when the
+* command runs, so `kubb --help` never does.
+*/
+function studioCommand({ action, block, ...definition }) {
+	return define({
+		...definition,
+		toKebab: true,
+		async run({ values }) {
+			const { runStudio } = await import("./run-WkXSXG2V.js");
+			await runStudio(values, action, { block });
+		}
+	});
+}
+//#endregion
 //#region src/commands/studio/connect.ts
-const command$8 = define({
+const command$11 = studioCommand({
 	name: "connect",
 	description: "Connect this project to Kubb Studio and generate from the browser.",
 	examples: [
@@ -275,7 +200,6 @@ const command$8 = define({
 		"kubb studio connect --allow-write --allow-exec",
 		"kubb studio connect --url http://localhost:3000"
 	].join("\n"),
-	toKebab: true,
 	args: {
 		...configArg,
 		...studioConnectionArgs,
@@ -288,45 +212,42 @@ const command$8 = define({
 		},
 		...logLevelArg
 	},
-	async run(ctx) {
-		const { connectRunner } = await import("./commands-BegVe5Mt.js");
-		await connectRunner(ctx);
+	block: true,
+	async action(options) {
+		const { connect } = await import("./run-WkXSXG2V.js");
+		await connect(options);
 	}
 });
 //#endregion
 //#region src/commands/studio/login.ts
-const command$7 = define({
+const command$10 = studioCommand({
 	name: "login",
 	description: "Pair this machine with Kubb Studio without connecting.",
 	examples: ["kubb studio login", "kubb studio login --url http://localhost:3000"].join("\n"),
-	toKebab: true,
-	args: command$8.args,
-	async run(ctx) {
-		const { loginRunner } = await import("./commands-BegVe5Mt.js");
-		await loginRunner(ctx);
+	args: command$11.args,
+	async action(options) {
+		const { login } = await import("./run-WkXSXG2V.js");
+		await login(options);
 	}
 });
 //#endregion
 //#region src/commands/studio/logout.ts
-const command$6 = define({
+const command$9 = studioCommand({
 	name: "logout",
 	description: "Forget the stored Kubb Studio token.",
-	examples: ["kubb studio logout"].join("\n"),
-	toKebab: true,
-	args: {
-		...configArg,
-		...studioConnectionArgs,
-		...studioPermissionArgs,
-		...logLevelArg
-	},
-	async run(ctx) {
-		const { logoutRunner } = await import("./commands-BegVe5Mt.js");
-		await logoutRunner(ctx);
+	examples: "kubb studio logout",
+	args: {},
+	async action() {
+		const { stopWorker } = await import("./background-CZ2nVKwB.js");
+		const { clearCredentials } = await import("./credentials-C8tjAhTo.js");
+		await stopWorker();
+		await clearCredentials();
+		console.log("Signed out of Kubb Studio.");
 	}
 });
 //#endregion
 //#region src/commands/studio/snapshot.ts
-const command$5 = define({
+const command$8 = define({
 	name: "snapshot",
 	description: "Generate and publish a Kubb Studio snapshot from CI.",
 	examples: ["kubb studio snapshot", "kubb studio snapshot --json"].join("\n"),
@@ -360,51 +281,69 @@ const command$5 = define({
 		...logLevelArg
 	},
 	async run(ctx) {
-		const { runner } = await import("./snapshot-C0WaZZiF.js");
+		const { runner } = await import("./snapshot-iEjgROga.js");
 		await runner(ctx);
 	}
 });
 //#endregion
 //#region src/commands/studio/background.ts
-const command$4 = define({
+const command$7 = studioCommand({
 	name: "start",
 	description: "Keep this project connected to Kubb Studio in the background.",
-	toKebab: true,
-	args: command$8.args,
-	async run(ctx) {
-		const { startRunner } = await import("./commands-BegVe5Mt.js");
-		await startRunner(ctx);
+	args: command$11.args,
+	async action(options) {
+		const { startWorker } = await import("./background-CZ2nVKwB.js");
+		await startWorker(options);
 	}
 });
 const stopCommand = define({
 	name: "stop",
 	description: "Stop this project's background connection and keep its pairing.",
 	async run() {
-		const { stopRunner } = await import("./commands-BegVe5Mt.js");
-		await stopRunner();
+		const { stopWorker } = await import("./background-CZ2nVKwB.js");
+		await stopWorker();
+		console.log("Background connection stopped.");
 	}
 });
 //#endregion
 //#region src/commands/studio/status.ts
-const command$3 = define({
+const command$6 = studioCommand({
 	name: "status",
 	description: "Show the project worker, Kubb Studio pairing, and saved permissions.",
-	examples: ["kubb studio status"].join("\n"),
-	toKebab: true,
-	args: {
-		...configArg,
-		...studioConnectionArgs,
-		...studioPermissionArgs,
-		...logLevelArg
-	},
-	async run(ctx) {
-		const { statusRunner } = await import("./commands-BegVe5Mt.js");
-		await statusRunner(ctx);
+	examples: "kubb studio status",
+	args: { url: studioConnectionArgs.url },
+	async action(options) {
+		const { getWorkerLogPath, getWorkerStatus } = await import("./background-CZ2nVKwB.js");
+		const { readCredentials } = await import("./credentials-C8tjAhTo.js");
+		const { formatPermissionRows } = await import("./run-WkXSXG2V.js");
+		const worker = await getWorkerStatus();
+		console.log(`Background connection: ${worker.state}${worker.running ? ` (PID ${worker.pid})` : ""}`);
+		console.log(`Logs: ${getWorkerLogPath()}`);
+		const credentials = await readCredentials();
+		if (!credentials) {
+			console.log("Not paired. Run `kubb studio login`.");
+			return;
+		}
+		console.log(`Paired with ${credentials.studioUrl} as ${styleText("cyan", credentials.agentSlug || credentials.agentId)}`);
+		if (credentials.studioUrl !== options.studioUrl) console.log(styleText("yellow", `Connecting to ${options.studioUrl} needs pairing again.`));
+		const remembered = credentials.projects?.[process$1.cwd()];
+		if (!remembered) {
+			console.log(styleText("dim", "No saved permissions for this project. Run `kubb studio` to connect and choose."));
+			return;
+		}
+		console.log(styleText("dim", "Saved permissions"));
+		for (const row of formatPermissionRows({
+			allowRead: remembered.allowRead === true,
+			allowWrite: remembered.allowWrite === true,
+			allowConfigEdit: remembered.allowConfigEdit === true,
+			allowExec: remembered.allowExec === true
+		})) console.log(row);
 	}
 });
 //#endregion
 //#region src/commands/studio/index.ts
-const command$2 = define({
+const command$5 = define({
+	...command$11,
 	name: "studio",
 	description: "Connect this project to Kubb Studio, or manage its pairing and snapshots.",
 	examples: [
@@ -415,20 +354,14 @@ const command$2 = define({
 		"kubb studio logout",
 		"kubb studio snapshot"
 	].join("\n"),
-	toKebab: true,
-	args: command$8.args,
-	async run(ctx) {
-		const { connectRunner } = await import("./commands-BegVe5Mt.js");
-		await connectRunner(ctx);
-	},
 	subCommands: {
-		start: command$4,
+		start: command$7,
 		stop: stopCommand,
-		connect: command$8,
-		login: command$7,
-		logout: command$6,
-		status: command$3,
-		snapshot: command$5
+		connect: command$11,
+		login: command$10,
+		logout: command$9,
+		status: command$6,
+		snapshot: command$8
 	}
 });
 /**
@@ -445,41 +378,9 @@ function routeStudioFlags(args) {
 	];
 }
 //#endregion
-//#region src/commands/update.ts
-const command$1 = define({
-	name: "update",
-	description: "Update installed extensions to the version the Kubb registry pins. Pass ids to update only those, or --check to list the updates without installing.",
-	examples: [
-		"kubb update",
-		"kubb update --check",
-		"kubb update plugin-zod plugin-ts --yes"
-	].join("\n"),
-	args: {
-		ids: {
-			type: "positional",
-			description: "Registry ids to update, all installed extensions when omitted",
-			multiple: true
-		},
-		check: {
-			type: "boolean",
-			description: "List the available updates without installing them",
-			default: false
-		},
-		...yesArg
-	},
-	async run({ values }) {
-		const { run } = await import("./run-Dej-hm91.js");
-		await run({
-			ids: values.ids ?? [],
-			check: values.check,
-			yes: values.yes
-		});
-	}
-});
-//#endregion
 //#region src/commands/validate.ts
 /** The runner is imported when the command runs, so listing `kubb --help` never loads `@kubb/adapter-oas`. */
-const command = define({
+const command$4 = define({
 	name: "validate",
 	description: "Parse and validate an OpenAPI/Swagger file for structural correctness. Reports schema errors, missing required fields, and malformed references. Use this before running generate to catch spec issues early.",
 	examples: ["kubb validate ./openapi.yaml", "kubb validate https://petstore3.swagger.io/api/v3/openapi.json"].join("\n"),
@@ -489,7 +390,7 @@ const command = define({
 		required: true
 	} },
 	async run({ values }) {
-		const { run } = await import("./run-BCswmM8Q.js");
+		const { run } = await import("./run-Ck04_W4q.js");
 		await run({ input: values.input });
 	}
 });
@@ -524,6 +425,596 @@ function resolveDeprecatedFlags(args) {
 	});
 }
 //#endregion
+//#region ../../internals/shared/src/init.ts
+/** The `kubb.config.ts` `kubb init` writes before `kubb add` puts each plugin in. */
+function generateConfigFile({ inputPath, outputPath }) {
+	return `import { defineConfig } from 'kubb/config'
+
+export default defineConfig({
+  input: '${inputPath}',
+  output: {
+    path: '${outputPath}',
+    clean: true,
+  },
+  plugins: [],
+})
+`;
+}
+//#endregion
+//#region src/runners/init/utils.ts
+/** Metadata for each supported package manager, keyed by its short name. */
+const packageManagers = {
+	pnpm: {
+		name: "pnpm",
+		lockFiles: ["pnpm-lock.yaml"],
+		initCommand: ["init"],
+		installCommand: ["add", "-D"]
+	},
+	yarn: {
+		name: "yarn",
+		lockFiles: ["yarn.lock"],
+		initCommand: ["init", "-y"],
+		installCommand: ["add", "-D"]
+	},
+	bun: {
+		name: "bun",
+		lockFiles: ["bun.lock", "bun.lockb"],
+		initCommand: ["init", "-y"],
+		installCommand: ["add", "-d"]
+	},
+	npm: {
+		name: "npm",
+		lockFiles: ["package-lock.json"],
+		initCommand: ["init", "-y"],
+		installCommand: ["install", "--save-dev"]
+	}
+};
+/** Detects the package manager for `cwd`: the `packageManager` field in `package.json`, then a lock file, then `npm`. */
+function detectPackageManager(cwd = process$1.cwd()) {
+	const packageJsonPath = path.join(cwd, "package.json");
+	if (fs.existsSync(packageJsonPath)) try {
+		const pmField = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8")).packageManager;
+		if (typeof pmField === "string") {
+			const name = pmField.split("@")[0];
+			if (name && name in packageManagers) return packageManagers[name];
+		}
+	} catch {}
+	for (const pm of Object.values(packageManagers)) if (pm.lockFiles.some((lockFile) => fs.existsSync(path.join(cwd, lockFile)))) return pm;
+	return packageManagers.npm;
+}
+/**
+* Initializes a new `package.json` at `cwd` using the detected package manager.
+*/
+async function initPackageJson(cwd, packageManager) {
+	await x(packageManager.name, [...packageManager.initCommand], {
+		nodeOptions: {
+			cwd,
+			stdio: "inherit"
+		},
+		throwOnError: true
+	});
+}
+/**
+* Installs the given packages at `cwd` using the detected package manager.
+*/
+async function installPackages(packages, packageManager, cwd = process$1.cwd()) {
+	await x(packageManager.name, [...packageManager.installCommand, ...packages], {
+		nodeOptions: {
+			cwd,
+			stdio: "inherit"
+		},
+		throwOnError: true
+	});
+}
+/**
+* What the installed manifests of the `selected` plugins say is missing from the selection: a
+* `dependencies` entry, or a `client` plugin next to a `consumer`. Empty when nothing is missing.
+* `optionalDependencies` are skipped, since `kubb init` writes the default options.
+*/
+function missingPluginDependencies({ selected, manifests }) {
+	const hasClient = manifests.some((manifest) => manifest.role === "client");
+	return manifests.flatMap((manifest) => [...(manifest.dependencies ?? []).filter((name) => !selected.includes(name)).map((name) => `${manifest.name} needs ${name}.`), ...manifest.role === "consumer" && !hasClient ? [`${manifest.name} needs a client plugin, such as plugin-axios or plugin-fetch.`] : []]);
+}
+//#endregion
+//#region src/runners/add/run.ts
+/** The import and the `defineConfig` property to merge into `kubb.config.ts` by hand. */
+function toSnippet({ artifact, manifest }) {
+	const call = `${manifest.export}()`;
+	const property = {
+		plugin: `plugins: [..., ${call}],`,
+		adapter: `adapter: ${call},`,
+		parser: `parsers: [..., ${call}],`
+	};
+	return [
+		`import { ${manifest.export} } from '${artifact.package}'`,
+		"",
+		property[manifest.kind]
+	].join("\n");
+}
+/** Adds the plugin call and its import to the config file. Returns why it could not, or `undefined`. */
+async function addToConfig({ detail, configFile }) {
+	const { artifact, manifest } = detail;
+	try {
+		const { writeConfigEdits } = await import("@kubb/studio");
+		const { outcomes } = await writeConfigEdits({
+			filePath: configFile,
+			edits: [{
+				operation: "add-plugin",
+				plugin: artifact.package
+			}],
+			extensions: /* @__PURE__ */ new Map([[artifact.package, {
+				package: artifact.package,
+				version: artifact.version,
+				manifest
+			}]])
+		});
+		return outcomes[0]?.applied ? void 0 : outcomes[0]?.reason ?? "the config file was not changed";
+	} catch (error) {
+		return getErrorMessage(error);
+	}
+}
+async function selectExtension(registry) {
+	const options = (await fetchRegistryIndex({ registry })).toSorted((a, b) => a.id.localeCompare(b.id)).map((entry) => ({
+		value: entry.id,
+		label: entry.manifest.displayName,
+		hint: `${entry.id} · ${entry.kind} ${entry.artifact.version} · ${entry.manifest.description}`
+	}));
+	if (!options.length) throw new Error(`The registry at ${registry} lists no extensions.`);
+	const id = await clack.autocomplete({
+		message: "Select an extension to add:",
+		options,
+		filter: (search, option) => `${option.label} ${option.hint}`.toLowerCase().includes(search.toLowerCase())
+	});
+	return clack.isCancel(id) ? void 0 : id;
+}
+/**
+* Installs an extension from the Kubb registry at its reviewed version and, for a plugin, adds it to
+* `kubb.config.ts`. Without an id, asks which one. Refuses when the running Kubb or Node.js version
+* is outside its compatibility.
+*/
+async function run$4({ id: input, configPath, yes, install }) {
+	const cwd = process$1.cwd();
+	logIntro({ title: styleText("bgCyan", styleText("black", " Kubb Add ")) });
+	try {
+		const registry = registryUrl();
+		if (!input && yes) throw new Error("Pass a registry id, such as plugin-zod, when using --yes.");
+		const id = input ? toRegistryId(input) : await selectExtension(registry);
+		if (!id) {
+			clack.cancel("Operation canceled.");
+			return;
+		}
+		const detail = await fetchRegistryDetail({
+			id,
+			registry
+		});
+		const { artifact, manifest } = detail;
+		const problem = incompatibility(manifest);
+		if (problem) throw new Error(problem);
+		const spec = installSpec(artifact);
+		const configFile = manifest.kind === "plugin" ? configPath ? path.resolve(configPath) : findConfigFile(cwd) : void 0;
+		if (manifest.kind === "plugin" && !configFile) throw new Error("No kubb.config.ts found. Run `kubb init` first, or pass --config.");
+		logInfo(`${styleText("cyan", manifest.displayName)} (${manifest.kind}): ${manifest.description}`);
+		logBlock([install ? `Install ${styleText("cyan", spec)} as a dev dependency` : `Skip installing ${spec}`, configFile ? `Add ${styleText("cyan", `${manifest.export}()`)} to ${path.relative(cwd, configFile) || configFile}` : `Print the ${manifest.kind} snippet to add`]);
+		const confirmed = yes || await clack.confirm({
+			message: "Continue?",
+			initialValue: true
+		});
+		if (clack.isCancel(confirmed) || !confirmed) {
+			clack.cancel("Operation canceled.");
+			return;
+		}
+		if (install) {
+			const packageManager = detectPackageManager(cwd);
+			logStep(`Installing ${spec} with ${packageManager.name}`);
+			await installPackages([spec], packageManager, cwd);
+		}
+		const reason = configFile ? await addToConfig({
+			detail,
+			configFile
+		}) : `add the ${manifest.kind} to your config`;
+		if (!reason) {
+			logOutro(styleText("green", install ? `Added ${spec}` : `Added ${manifest.export}() to the config. Install ${spec} to use it.`));
+			return;
+		}
+		if (configFile) logWarn(`Could not edit ${configFile}: ${reason}`);
+		logBlock([
+			"Add the import to your Kubb config and merge the property into its defineConfig call:",
+			"",
+			toSnippet(detail)
+		]);
+		logOutro(styleText("green", install ? `Installed ${spec}. Add it with the snippet above.` : `Install ${spec} and add the snippet above.`));
+	} catch (error) {
+		logError(getErrorMessage(error));
+		process$1.exitCode = 1;
+	}
+}
+__name(run$4, "run");
+const command$3 = define({
+	name: "add",
+	description: "Install a plugin, adapter, or parser from the Kubb registry at its reviewed version. Without an id, pick one from the registry. A plugin is added to kubb.config.ts, an adapter or parser prints the code to add. Reads KUBB_REGISTRY to use another registry.",
+	examples: [
+		"kubb add",
+		"kubb add plugin-zod",
+		"kubb add kubb-labs/plugin-react-query",
+		"kubb add acme/plugin-x --yes",
+		"kubb add plugin-zod --no-install"
+	].join("\n"),
+	toKebab: true,
+	args: {
+		id: {
+			type: "positional",
+			description: "Registry id: owner/slug, or a slug for an official extension. Asked for when omitted",
+			required: false
+		},
+		...configArg,
+		...yesArg,
+		install: {
+			type: "boolean",
+			description: "Install the package. Pass --no-install to only edit the config",
+			negatable: true,
+			default: true
+		}
+	},
+	run: ({ values }) => run$4({
+		id: values.id,
+		configPath: values.config,
+		yes: values.yes,
+		install: values.install
+	})
+});
+//#endregion
+//#region src/runners/init/run.ts
+function cancelAndExit(message = "Operation canceled.") {
+	clack.cancel(message);
+	process$1.exit(0);
+}
+/**
+* Runs the interactive Kubb scaffolding wizard.
+* Detects the package manager, prompts for input/output paths and plugins, installs packages, and writes `kubb.config.ts`.
+* Pass `yes: true` to skip all prompts and use defaults.
+*/
+async function run$3({ yes, input: inputFlag, output: outputFlag, plugins: pluginsFlag, dryRun }) {
+	const cwd = process$1.cwd();
+	logIntro({ title: styleText("bgCyan", styleText("black", " Kubb Init ")) });
+	/**
+	* Returns `flag` when provided, the `defaultValue` when `yes` is set,
+	* or calls `prompt()` for interactive input. Exits on cancellation.
+	*/
+	async function resolveOrPrompt(flag, defaultValue, logLabel, prompt) {
+		if (flag !== void 0) {
+			logInfo(`${logLabel}: ${styleText("cyan", String(flag))}`);
+			return flag;
+		}
+		if (yes) {
+			logInfo(`${logLabel}: ${styleText("cyan", String(defaultValue))}`);
+			return defaultValue;
+		}
+		const result = await prompt();
+		if (clack.isCancel(result)) cancelAndExit();
+		return result;
+	}
+	try {
+		const plugins = (await fetchRegistryIndex({ registry: registryUrl() })).filter((entry) => entry.kind === "plugin" && !incompatibility(entry.manifest));
+		const byId = new Map(plugins.map((entry) => [entry.id, entry]));
+		if (!fs.existsSync(path.join(cwd, "package.json"))) {
+			if (!yes) {
+				const shouldInit = await clack.confirm({
+					message: "No package.json found. Would you like to create one?",
+					initialValue: true
+				});
+				if (clack.isCancel(shouldInit) || !shouldInit) cancelAndExit();
+			}
+			const packageManager = detectPackageManager(cwd);
+			const spinner = createSpinner();
+			spinner.start(`Initializing package.json with ${packageManager.name}`);
+			await initPackageJson(cwd, packageManager);
+			spinner.stop(`Created package.json with ${packageManager.name}`);
+		}
+		const packageManager = detectPackageManager(cwd);
+		logInfo(`Detected package manager: ${styleText("cyan", packageManager.name)}`);
+		const inputPath = await resolveOrPrompt(inputFlag, initDefaults.inputPath, "Using input path", () => clack.text({
+			message: "Where is your OpenAPI specification located?",
+			placeholder: initDefaults.inputPath,
+			defaultValue: initDefaults.inputPath,
+			validate: (value) => {
+				if (!value) return "Input path is required";
+			}
+		}));
+		const outputPath = await resolveOrPrompt(outputFlag, initDefaults.outputPath, "Using output path", () => clack.text({
+			message: "Where should the generated files be output?",
+			placeholder: initDefaults.outputPath,
+			defaultValue: initDefaults.outputPath,
+			validate: (value) => {
+				if (!value) return "Output path is required";
+			}
+		}));
+		const defaultPlugins = initDefaults.plugins.flatMap((slug) => byId.get(toRegistryId(slug)) ?? []);
+		const pluginLabel = (entries) => styleText("cyan", entries.map((entry) => entry.manifest.displayName).join(", "));
+		const selectedPlugins = await (async () => {
+			if (pluginsFlag) {
+				const ids = pluginsFlag.split(",").map((id) => id.trim()).filter(Boolean);
+				const unknown = ids.filter((id) => !byId.has(toRegistryId(id)));
+				if (unknown.length) throw new Error(`Not in the Kubb registry: ${unknown.join(", ")}. Browse the plugins at https://kubb.dev/extensions.`);
+				const entries = ids.map((id) => byId.get(toRegistryId(id)));
+				logInfo(`Using plugins: ${pluginLabel(entries)}`);
+				return entries;
+			}
+			if (yes) {
+				logInfo(`Using plugins: ${pluginLabel(defaultPlugins)}`);
+				return defaultPlugins;
+			}
+			const values = await clack.multiselect({
+				message: "Select plugins to use:",
+				options: plugins.map(({ id, manifest }) => ({
+					value: id,
+					label: manifest.displayName,
+					hint: manifest.category
+				})),
+				initialValues: defaultPlugins.map((entry) => entry.id),
+				required: true
+			});
+			if (clack.isCancel(values)) cancelAndExit();
+			return plugins.filter((entry) => values.includes(entry.id));
+		})();
+		const missing = missingPluginDependencies({
+			selected: selectedPlugins.map((entry) => entry.manifest.name),
+			manifests: selectedPlugins.map((entry) => entry.manifest)
+		});
+		if (missing.length) throw new Error(`${missing.join("\n")}\nAdd the missing plugins and run kubb init again.`);
+		const packagesToInstall = [`${KUBB_PACKAGE_NAME}@${version}`, ...selectedPlugins.map((entry) => installSpec(entry.artifact))];
+		const spinner = createSpinner();
+		spinner.start(`Installing ${packagesToInstall.length} packages with ${packageManager.name}`);
+		try {
+			await dryRun.run(() => installPackages(packagesToInstall, packageManager, cwd), { message: `install ${packagesToInstall.length} packages with ${packageManager.name}` });
+			spinner.stop(`Installed ${packagesToInstall.length} packages`);
+		} catch (error) {
+			spinner.stop("Installation failed");
+			throw error;
+		}
+		const configSpinner = createSpinner();
+		configSpinner.start(`Creating ${KUBB_CONFIG_FILENAME}`);
+		const configContent = generateConfigFile({
+			inputPath,
+			outputPath
+		});
+		const configPath = path.join(cwd, KUBB_CONFIG_FILENAME);
+		if (fs.existsSync(configPath)) {
+			configSpinner.stop(`${KUBB_CONFIG_FILENAME} already exists`);
+			if (!yes) {
+				const shouldOverwrite = await clack.confirm({
+					message: `${KUBB_CONFIG_FILENAME} already exists. Overwrite?`,
+					initialValue: false
+				});
+				if (clack.isCancel(shouldOverwrite) || !shouldOverwrite) cancelAndExit("Keeping existing configuration. Packages have been installed.");
+			}
+			configSpinner.start(`Overwriting ${KUBB_CONFIG_FILENAME}`);
+		}
+		await dryRun.run(() => fs.promises.writeFile(configPath, configContent, "utf-8"), { message: `write ${KUBB_CONFIG_FILENAME}` });
+		for (const entry of selectedPlugins) {
+			const reason = await dryRun.run(() => addToConfig({
+				detail: entry,
+				configFile: configPath
+			}), {
+				message: `add ${entry.manifest.export}() to ${KUBB_CONFIG_FILENAME}`,
+				resolve: () => void 0
+			});
+			if (reason) throw new Error(`Could not add ${entry.manifest.export}() to ${KUBB_CONFIG_FILENAME}: ${reason}`);
+		}
+		configSpinner.stop(`Created ${KUBB_CONFIG_FILENAME}`);
+		logOutro(styleText("green", "✓ All set!") + "\n\n" + styleText("dim", "Next steps:") + "\n" + styleText("cyan", `  1. Make sure your OpenAPI spec is at: ${inputPath}`) + "\n" + styleText("cyan", "  2. Generate code with: npx kubb generate") + "\n" + styleText("cyan", `  3. Find generated files in: ${outputPath}`) + "\n\n" + styleText("dim", `Using ${packageManager.name} • Kubb v${version}`));
+	} catch (error) {
+		logError(styleText("red", "An error occurred during initialization"));
+		if (error instanceof Error) logError(error.message);
+		process$1.exit(1);
+	}
+}
+__name(run$3, "run");
+const command$2 = defineWithTypes()({
+	name: "init",
+	description: "Scaffold a kubb.config.ts and install plugins for code generation from an OpenAPI spec. Run without flags for interactive setup, or pass --input, --output, and --plugins to skip the prompts.",
+	examples: [
+		"kubb init",
+		"kubb init --yes",
+		"kubb init --input ./openapi.yaml --output ./src/gen --plugins plugin-ts,plugin-zod",
+		"kubb init --plugins plugin-ts,plugin-axios,plugin-react-query",
+		"kubb init --yes --dry-run"
+	].join("\n"),
+	toKebab: true,
+	args: {
+		yes: {
+			type: "boolean",
+			description: "Skip prompts and use default options",
+			short: "y",
+			default: false
+		},
+		input: {
+			type: "string",
+			description: "Path to the OpenAPI specification",
+			short: "i",
+			metavar: "path"
+		},
+		output: {
+			type: "string",
+			description: "Output directory for generated files",
+			short: "o",
+			metavar: "path"
+		},
+		plugins: {
+			type: "string",
+			description: "Comma-separated Kubb registry ids of the plugins to add, the same ids `kubb add` takes (plugin-ts, plugin-zod, acme/plugin-x)",
+			metavar: "plugin-ts,plugin-zod,..."
+		}
+	},
+	run: ({ values, extensions }) => run$3({
+		yes: values.yes,
+		input: values.input,
+		output: values.output,
+		plugins: values.plugins,
+		dryRun: extensions[dryRunId]
+	})
+});
+//#endregion
+//#region src/runners/list/run.ts
+/**
+* The installed packages that ship a `kubb-extension.json` or have a registry entry, with the
+* version the registry pins.
+*/
+async function listExtensions({ cwd, registry }) {
+	const [installed, entries] = await Promise.all([readInstalledPackages({ root: cwd }), fetchRegistryIndex({ registry }).catch((error) => {
+		logWarn(`Showing installed extensions only: ${getErrorMessage(error)}`);
+		return [];
+	})]);
+	const byPackage = new Map(entries.map((entry) => [entry.artifact.package, entry]));
+	return installed.flatMap(({ package: name, version, manifest }) => {
+		const entry = byPackage.get(name);
+		if (!entry && !manifest) return [];
+		const latest = entry?.artifact.version;
+		return [{
+			id: entry?.id,
+			package: name,
+			installed: version,
+			registry: latest,
+			update: !!latest && isOutdated({
+				installed: version,
+				latest
+			})
+		}];
+	});
+}
+/** Prints the installed extensions as a table. */
+async function run$2() {
+	try {
+		const rows = await listExtensions({
+			cwd: process$1.cwd(),
+			registry: registryUrl()
+		});
+		if (!rows.length) {
+			logOutro("No installed extensions found.");
+			return;
+		}
+		const header = [
+			"ID",
+			"PACKAGE",
+			"INSTALLED",
+			"REGISTRY",
+			"UPDATE"
+		];
+		const cells = rows.map((row) => [
+			row.id ?? "-",
+			row.package,
+			row.installed ?? "-",
+			row.registry ?? "-",
+			row.update ? "yes" : "no"
+		]);
+		const widths = header.map((title, index) => Math.max(title.length, ...cells.map((cell) => cell[index].length)));
+		const line = (cell) => cell.map((value, index) => value.padEnd(widths[index])).join("  ").trimEnd();
+		logBlock([styleText("dim", line(header)), ...cells.map(line)]);
+	} catch (error) {
+		logError(getErrorMessage(error));
+		process$1.exitCode = 1;
+	}
+}
+__name(run$2, "run");
+const command$1 = define({
+	name: "list",
+	description: "List the installed Kubb extensions: their registry id, package, installed version, the version the Kubb registry pins, and whether an update exists.",
+	examples: "kubb list",
+	run: () => run$2()
+});
+//#endregion
+//#region src/runners/update/run.ts
+/**
+* Moves installed extensions to the version the registry pins. Lists the proposals, asks, then
+* installs them. With `check`, only lists them.
+*/
+async function run$1({ ids, check, yes }) {
+	const cwd = process$1.cwd();
+	logIntro({ title: styleText("bgCyan", styleText("black", " Kubb Update ")) });
+	try {
+		const wanted = new Set(ids.map(toRegistryId));
+		const [entries, installed] = await Promise.all([fetchRegistryIndex({ registry: registryUrl() }), readInstalledPackages({ root: cwd })]);
+		const versions = new Map(installed.map((item) => [item.package, item.version]));
+		const tracked = entries.filter((entry) => versions.has(entry.artifact.package) && (!wanted.size || wanted.has(entry.id)));
+		for (const id of wanted) if (!tracked.some((entry) => entry.id === id)) logWarn(`${id} is not installed, or not in the registry.`);
+		const proposals = tracked.filter((entry) => {
+			if (!isOutdated({
+				installed: versions.get(entry.artifact.package),
+				latest: entry.artifact.version
+			})) return false;
+			const problem = incompatibility(entry.manifest);
+			if (problem) logWarn(`Skipped ${entry.id}: ${problem}`);
+			return !problem;
+		});
+		if (!proposals.length) {
+			logOutro(ids.length ? `No updates for ${ids.join(", ")}.` : "Every installed extension is up to date.");
+			return;
+		}
+		const change = ({ kind, artifact }) => `${kind}  ${versions.get(artifact.package) ?? "not installed"} -> ${styleText("green", artifact.version)}`;
+		logBlock(proposals.map((entry) => `${entry.artifact.package}  ${change(entry)}`));
+		if (check) {
+			const plural = proposals.length === 1 ? "" : "s";
+			logOutro(`${proposals.length} update${plural} available. Run \`kubb update\` to install.`);
+			return;
+		}
+		let selected = proposals;
+		if (!yes) {
+			const chosen = await clack.multiselect({
+				message: "Select the updates to install:",
+				options: proposals.map((entry) => ({
+					value: entry.id,
+					label: entry.artifact.package,
+					hint: change(entry)
+				})),
+				initialValues: proposals.map((entry) => entry.id),
+				required: true
+			});
+			if (clack.isCancel(chosen)) {
+				clack.cancel("Operation canceled.");
+				return;
+			}
+			selected = proposals.filter((entry) => chosen.includes(entry.id));
+		}
+		const plural = selected.length === 1 ? "" : "s";
+		const packageManager = detectPackageManager(cwd);
+		const specs = selected.map(({ artifact }) => installSpec(artifact));
+		logStep(`Installing ${specs.join(", ")} with ${packageManager.name}`);
+		await installPackages(specs, packageManager, cwd);
+		logInfo(`Updated ${specs.length} extension${plural}`);
+		logOutro(styleText("green", "Done"));
+	} catch (error) {
+		logError(getErrorMessage(error));
+		process$1.exitCode = 1;
+	}
+}
+__name(run$1, "run");
+const command = define({
+	name: "update",
+	description: "Update installed extensions to the version the Kubb registry pins. Pass ids to update only those, or --check to list the updates without installing.",
+	examples: [
+		"kubb update",
+		"kubb update --check",
+		"kubb update plugin-zod plugin-ts --yes"
+	].join("\n"),
+	args: {
+		ids: {
+			type: "positional",
+			description: "Registry ids to update, all installed extensions when omitted",
+			multiple: true
+		},
+		check: {
+			type: "boolean",
+			description: "List the available updates without installing them",
+			default: false
+		},
+		...yesArg
+	},
+	run: ({ values }) => run$1({
+		ids: values.ids ?? [],
+		check: values.check,
+		yes: values.yes
+	})
+});
+//#endregion
 //#region src/index.ts
 /** Flags that short-circuit execution (help and version). The telemetry notice is suppressed for these. */
 const QUIET_FLAGS = /* @__PURE__ */ new Set([
@@ -541,19 +1032,19 @@ async function run(argv = process.argv.slice(2)) {
 	const args = routeStudioFlags(resolveDeprecatedFlags(argv));
 	const isQuietFlag = args.some((arg) => QUIET_FLAGS.has(arg));
 	if (!isDisabled() && !isQuietFlag) console.error(`${styleText("yellow", "Notice:")} Kubb collects anonymous telemetry data to help improve the tool. No personal data or file contents are collected. \nTo disable, set ${styleText("cyan", "KUBB_DISABLE_TELEMETRY=1")}.\n`);
-	await cli(args, command$12, {
+	await cli(args, command$13, {
 		name: "kubb",
 		version,
 		description: "Generate code from an OpenAPI specification, manage Kubb extensions, or connect the project to Kubb Studio.",
 		subCommands: {
-			generate: command$12,
-			init: command$11,
-			validate: command,
-			mcp: command$9,
-			studio: command$2,
-			add: command$13,
-			update: command$1,
-			list: command$10
+			generate: command$13,
+			init: command$2,
+			validate: command$4,
+			mcp: command$12,
+			studio: command$5,
+			add: command$3,
+			update: command,
+			list: command$1
 		},
 		fallbackToEntry: true,
 		strict: true,