@kubb/cli 5.0.0-beta.6 → 5.0.0-beta.61

package/src/runners/{init.ts → init/run.ts}

@@ -3,32 +3,68 @@ import path from 'node:path'
 import process from 'node:process'
 import { styleText } from 'node:util'
 import * as clack from '@clack/prompts'
-import type { PackageManagerInfo } from '@internals/utils'
 import { detectPackageManager } from '@internals/utils'
 import { availablePlugins, generateConfigFile, initDefaults, KUBB_CONFIG_FILENAME, type PluginOption } from '@internals/shared'
-import { hasPackageJson, initPackageJson, installPackages } from '../utils/packageManager.ts'
+import { hasPackageJson, initPackageJson, installPackages } from './utils.ts'
 
-function cancelAndExit(message = 'Operation cancelled.'): never {
+function cancelAndExit(message = 'Operation canceled.'): never {
   clack.cancel(message)
   process.exit(0)
 }
 
 type InitOptions = {
+  /**
+   * When `true`, skips all interactive prompts and uses default values.
+   */
   yes: boolean
+  /**
+   * Current `@kubb/cli` version string, shown in the outro and used for package installation.
+   */
   version: string
+  /**
+   * Input path flag value from `--input`. When provided, skips the input prompt.
+   */
   input?: string
+  /**
+   * Output directory flag value from `--output`. When provided, skips the output prompt.
+   */
   output?: string
+  /**
+   * Comma-separated plugin list from `--plugins`, e.g. `'plugin-ts,plugin-zod'`. When provided, skips the plugin selection prompt.
+   */
   plugins?: string
 }
 
-export async function runInit({ yes, version, input: inputFlag, output: outputFlag, plugins: pluginsFlag }: InitOptions): Promise<void> {
+/**
+ * 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.
+ */
+export async function run({ yes, version, input: inputFlag, output: outputFlag, plugins: pluginsFlag }: InitOptions): Promise<void> {
   const cwd = process.cwd()
 
   clack.intro(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<T>(flag: T | undefined, defaultValue: T, logLabel: string, prompt: () => Promise<T | symbol>): Promise<T> {
+    if (flag !== undefined) {
+      clack.log.info(`${logLabel}: ${styleText('cyan', String(flag))}`)
+      return flag
+    }
+    if (yes) {
+      clack.log.info(`${logLabel}: ${styleText('cyan', String(defaultValue))}`)
+      return defaultValue
+    }
+    const result = await prompt()
+    if (clack.isCancel(result)) cancelAndExit()
+    return result as T
+  }
+
   try {
-    // Check/create package.json
-    let packageManager: PackageManagerInfo
+    // Check/create package.json, detect package manager once after the block
     if (!hasPackageJson(cwd)) {
       if (!yes) {
         const shouldInit = await clack.confirm({
@@ -41,104 +77,73 @@ export async function runInit({ yes, version, input: inputFlag, output: outputFl
         }
       }
 
-      packageManager = detectPackageManager(cwd)
-
+      const packageManager = detectPackageManager(cwd)
       const spinner = clack.spinner()
       spinner.start(`Initializing package.json with ${packageManager.name}`)
-
       await initPackageJson(cwd, packageManager)
-
       spinner.stop(`Created package.json with ${packageManager.name}`)
-    } else {
-      packageManager = detectPackageManager(cwd)
+    }
+
+    const packageManager = detectPackageManager(cwd)
+    if (hasPackageJson(cwd)) {
       clack.log.info(`Detected package manager: ${styleText('cyan', packageManager.name)}`)
     }
 
     // Prompt for OpenAPI spec path
-    let inputPath: string
-    if (inputFlag) {
-      inputPath = inputFlag
-      clack.log.info(`Using input path: ${styleText('cyan', inputPath)}`)
-    } else if (yes) {
-      inputPath = initDefaults.inputPath
-      clack.log.info(`Using input path: ${styleText('cyan', inputPath)}`)
-    } else {
-      const inputPathResult = await clack.text({
+    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'
         },
-      })
-
-      if (clack.isCancel(inputPathResult)) {
-        cancelAndExit()
-      }
-      inputPath = inputPathResult as string
-    }
+      }),
+    )
 
     // Prompt for output directory
-    let outputPath: string
-    if (outputFlag) {
-      outputPath = outputFlag
-      clack.log.info(`Using output path: ${styleText('cyan', outputPath)}`)
-    } else if (yes) {
-      outputPath = initDefaults.outputPath
-      clack.log.info(`Using output path: ${styleText('cyan', outputPath)}`)
-    } else {
-      const outputPathResult = await clack.text({
+    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'
         },
-      })
-
-      if (clack.isCancel(outputPathResult)) {
-        cancelAndExit()
-      }
-      outputPath = outputPathResult as string
-    }
+      }),
+    )
 
     // Plugin selection
-    let selectedPlugins: PluginOption[]
-    if (pluginsFlag) {
-      const requestedValues = pluginsFlag
-        .split(',')
-        .map((v) => v.trim())
-        .filter(Boolean)
-      selectedPlugins = availablePlugins.filter((plugin) => requestedValues.includes(plugin.value))
-      if (selectedPlugins.length === 0) {
-        selectedPlugins = availablePlugins.filter((plugin) => (initDefaults.plugins as readonly string[]).includes(plugin.value))
-        clack.log.warn(
-          `No valid plugins found in --plugins value; falling back to default: ${styleText('cyan', selectedPlugins.map((p) => p.label).join(', '))}`,
-        )
-      } else {
-        clack.log.info(`Using plugins: ${styleText('cyan', selectedPlugins.map((p) => p.label).join(', '))}`)
+    const defaultPlugins = availablePlugins.filter((p) => (initDefaults.plugins as ReadonlyArray<string>).includes(p.value))
+    const pluginLabel = (plugins: Array<PluginOption>) => styleText('cyan', plugins.map((p) => p.label).join(', '))
+
+    const selectedPlugins: Array<PluginOption> = await (async () => {
+      if (pluginsFlag) {
+        const requested = pluginsFlag
+          .split(',')
+          .map((v) => v.trim())
+          .filter(Boolean)
+        const plugins = availablePlugins.filter((p) => requested.includes(p.value))
+        if (plugins.length === 0) {
+          clack.log.warn(`No valid plugins found in --plugins value; falling back to default: ${pluginLabel(defaultPlugins)}`)
+          return defaultPlugins
+        }
+        clack.log.info(`Using plugins: ${pluginLabel(plugins)}`)
+        return plugins
       }
-    } else if (yes) {
-      selectedPlugins = availablePlugins.filter((plugin) => (initDefaults.plugins as readonly string[]).includes(plugin.value))
-      clack.log.info(`Using plugins: ${styleText('cyan', selectedPlugins.map((p) => p.label).join(', '))}`)
-    } else {
-      const selectedPluginValues = await clack.multiselect({
+      if (yes) {
+        clack.log.info(`Using plugins: ${pluginLabel(defaultPlugins)}`)
+        return defaultPlugins
+      }
+      const values = await clack.multiselect({
         message: 'Select plugins to use:',
-        options: availablePlugins.map((plugin) => ({
-          value: plugin.value,
-          label: plugin.label,
-          hint: plugin.hint,
-        })),
+        options: availablePlugins.map(({ value, label, hint }) => ({ value, label, hint })),
         initialValues: [...initDefaults.plugins],
         required: true,
       })
-
-      if (clack.isCancel(selectedPluginValues)) {
-        cancelAndExit()
-      }
-
-      selectedPlugins = availablePlugins.filter((plugin) => (selectedPluginValues as string[]).includes(plugin.value))
-    }
+      if (clack.isCancel(values)) cancelAndExit()
+      return availablePlugins.filter((p) => (values as Array<string>).includes(p.value))
+    })()
 
     // Install packages
     const packagesToInstall = ['kubb', ...selectedPlugins.map((p) => p.packageName)]
@@ -178,7 +183,7 @@ export async function runInit({ yes, version, input: inputFlag, output: outputFl
       configSpinner.start(`Overwriting ${KUBB_CONFIG_FILENAME}`)
     }
 
-    fs.writeFileSync(configPath, configContent, 'utf-8')
+    await fs.promises.writeFile(configPath, configContent, 'utf-8')
 
     configSpinner.stop(`Created ${KUBB_CONFIG_FILENAME}`)
 
@@ -191,8 +196,6 @@ export async function runInit({ yes, version, input: inputFlag, output: outputFl
         '\n' +
         styleText('cyan', '  2. Generate code with: npx kubb generate') +
         '\n' +
-        styleText('cyan', '     Or start a stream server with: npx kubb start') +
-        '\n' +
         styleText('cyan', `  3. Find generated files in: ${outputPath}`) +
         '\n\n' +
         styleText('dim', `Using ${packageManager.name} • Kubb v${version}`),

package/src/runners/init/utils.ts

@@ -0,0 +1,39 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import process from 'node:process'
+import type { PackageManagerInfo, PackageManagerName } from '@internals/utils'
+import { x } from 'tinyexec'
+
+/**
+ * Returns `true` when a `package.json` exists at `cwd`.
+ */
+export function hasPackageJson(cwd: string = process.cwd()): boolean {
+  return fs.existsSync(path.join(cwd, 'package.json'))
+}
+
+/**
+ * Initializes a new `package.json` at `cwd` using the detected package manager.
+ */
+export async function initPackageJson(cwd: string, packageManager: PackageManagerInfo): Promise<void> {
+  const commands: Record<PackageManagerName, Array<string>> = {
+    npm: ['init', '-y'],
+    pnpm: ['init'],
+    yarn: ['init', '-y'],
+    bun: ['init', '-y'],
+  }
+
+  await x(packageManager.name, commands[packageManager.name], {
+    nodeOptions: { cwd, stdio: 'inherit' },
+    throwOnError: true,
+  })
+}
+
+/**
+ * Installs the given packages at `cwd` using the detected package manager.
+ */
+export async function installPackages(packages: Array<string>, packageManager: PackageManagerInfo, cwd: string = process.cwd()): Promise<void> {
+  await x(packageManager.name, [...packageManager.installCommand, ...packages], {
+    nodeOptions: { cwd, stdio: 'inherit' },
+    throwOnError: true,
+  })
+}

package/src/runners/mcp/run.ts

@@ -0,0 +1,37 @@
+import process from 'node:process'
+import { styleText } from 'node:util'
+import { getErrorMessage } from '@internals/utils'
+import { Telemetry } from '../../Telemetry.ts'
+import type * as McpModule from '@kubb/mcp'
+
+type McpOptions = {
+  /**
+   * Current `@kubb/cli` version string, used for the telemetry payload.
+   */
+  version: string
+  /**
+   * TCP port for the HTTP MCP server. When `undefined`, the server uses stdio transport.
+   */
+  port?: string
+  /**
+   * Hostname to bind to when running in HTTP mode.
+   *
+   * @default 'localhost'
+   */
+  host?: string
+}
+
+export async function run({ version, port, host }: McpOptions): Promise<void> {
+  const { run: startMcpServer } = (await import('@kubb/mcp')) as typeof McpModule
+  const hrStart = process.hrtime()
+  const report = (status: 'success' | 'failed') => Telemetry.send(Telemetry.build({ command: 'mcp', kubbVersion: version, hrStart, status }))
+  try {
+    console.log(styleText('cyan', '⏳ Starting MCP server...'))
+    console.warn(styleText('yellow', 'This feature is still under development, use with caution'))
+    await startMcpServer(undefined, { port: port !== undefined ? Number(port) : undefined, host })
+    await report('success')
+  } catch (error) {
+    await report('failed')
+    console.error(getErrorMessage(error))
+  }
+}

package/src/runners/{validate.ts → validate/run.ts}

@@ -1,47 +1,52 @@
 import process from 'node:process'
 import { styleText } from 'node:util'
 import { getErrorMessage } from '@internals/utils'
-import { buildTelemetryEvent, sendTelemetry } from '../utils/telemetry.ts'
+import { Telemetry } from '../../Telemetry.ts'
 
 type ValidateOptions = {
+  /**
+   * Path or URL to the OpenAPI/Swagger file to validate.
+   */
   input: string
+  /**
+   * Current `@kubb/cli` version string, used for the telemetry payload.
+   */
   version: string
 }
 
 type ValidateModule = typeof import('@kubb/adapter-oas')
 type ValidateDependencies = {
+  /**
+   * Loads `@kubb/adapter-oas`. Injected so tests can substitute a mock.
+   */
   loadValidateModule: () => Promise<ValidateModule>
 }
 
+/**
+ * Dynamically loads `@kubb/adapter-oas` for OpenAPI validation.
+ */
 export function loadValidateModule(): Promise<ValidateModule> {
   return import('@kubb/adapter-oas') as Promise<ValidateModule>
 }
 
-export async function runValidate({ input, version }: ValidateOptions, dependencies: ValidateDependencies = { loadValidateModule }): Promise<void> {
+/**
+ * Validates an OpenAPI/Swagger file at `input` using `@kubb/adapter-oas`.
+ * Exits the process with code 1 on validation failure or missing dependency.
+ */
+export async function run({ input, version }: ValidateOptions, dependencies: ValidateDependencies = { loadValidateModule }): Promise<void> {
   const hrStart = process.hrtime()
+  const report = (status: 'success' | 'failed') => Telemetry.send(Telemetry.build({ command: 'validate', kubbVersion: version, hrStart, status }))
   try {
     const { adapterOas } = await dependencies.loadValidateModule()
     const adapter = adapterOas()
-    await adapter.validate!(input, { throwOnError: true })
-
-    await sendTelemetry(
-      buildTelemetryEvent({
-        command: 'validate',
-        kubbVersion: version,
-        hrStart,
-        status: 'success',
-      }),
-    )
+    if (!adapter.validate) {
+      throw new Error('The loaded adapter does not support validation.')
+    }
+    await adapter.validate(input, { throwOnError: true })
+    await report('success')
     console.log('✅ Validation success')
   } catch (error) {
-    await sendTelemetry(
-      buildTelemetryEvent({
-        command: 'validate',
-        kubbVersion: version,
-        hrStart,
-        status: 'failed',
-      }),
-    )
+    await report('failed')
     if (error instanceof Error && /@kubb\/adapter-oas/.test(error.message)) {
       console.error(styleText('red', 'The @kubb/adapter-oas package is not installed.'))
       console.error('')

package/dist/agent-BJEvbSiP.js

@@ -1,68 +0,0 @@
-import "./chunk--u3MIqq1.js";
-import { n as defineCommand } from "./define-Ctii4bel.js";
-import { t as version } from "./package-vLafMWCe.js";
-import { o as agentDefaults } from "./constants-BPJBMT_6.js";
-//#endregion
-//#region src/commands/agent.ts
-const command = defineCommand({
-	name: "agent",
-	description: "Manage the Kubb Agent — an HTTP server that lets AI agents trigger code generation programmatically via a REST API. Useful when an AI workflow needs to generate code without direct CLI access.",
-	examples: [
-		"kubb agent start",
-		"kubb agent start --port 4000 --allow-write",
-		"kubb agent start --config ./kubb.config.ts --allow-all"
-	],
-	subCommands: [defineCommand({
-		name: "start",
-		description: "Start the Kubb Agent HTTP server. Exposes a REST API that accepts a kubb.config.ts patch and returns generated code as a stream. Use --allow-write to also write files to disk.",
-		examples: [
-			"kubb agent start",
-			"kubb agent start --port 4000",
-			"kubb agent start --allow-write",
-			"kubb agent start --config ./kubb.config.ts --allow-all"
-		],
-		options: {
-			config: {
-				type: "string",
-				description: "Path to the Kubb config file",
-				short: "c"
-			},
-			port: {
-				type: "string",
-				description: "Port the HTTP server listens on",
-				short: "p",
-				default: agentDefaults.port
-			},
-			host: {
-				type: "string",
-				description: "Hostname the HTTP server binds to",
-				default: agentDefaults.host
-			},
-			"allow-write": {
-				type: "boolean",
-				description: "Write generated files to the filesystem. When omitted, output is streamed only and no files are written.",
-				default: false
-			},
-			"allow-all": {
-				type: "boolean",
-				description: "Grant all permissions (implies --allow-write).",
-				default: false
-			}
-		},
-		async run({ values }) {
-			const { runAgentStart } = await import("./agent-VXKxLCho.js");
-			await runAgentStart({
-				port: values.port !== void 0 ? values.port : void 0,
-				host: values.host,
-				configPath: values.config,
-				allowWrite: values["allow-write"],
-				allowAll: values["allow-all"],
-				version
-			});
-		}
-	})]
-});
-//#endregion
-export { command };
-
-//# sourceMappingURL=agent-BJEvbSiP.js.map

package/dist/agent-BJEvbSiP.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"agent-BJEvbSiP.js","names":["command","startCommand"],"sources":["../src/commands/agent/start.ts","../src/commands/agent.ts"],"sourcesContent":["import { defineCommand } from '@internals/utils'\nimport { version } from '../../../package.json'\nimport { agentDefaults } from '../../constants.ts'\n\nexport const command = defineCommand({\n  name: 'start',\n  description:\n    'Start the Kubb Agent HTTP server. Exposes a REST API that accepts a kubb.config.ts patch and returns generated code as a stream. Use --allow-write to also write files to disk.',\n  examples: ['kubb agent start', 'kubb agent start --port 4000', 'kubb agent start --allow-write', 'kubb agent start --config ./kubb.config.ts --allow-all'],\n  options: {\n    config: {\n      type: 'string',\n      description: 'Path to the Kubb config file',\n      short: 'c',\n    },\n    port: {\n      type: 'string',\n      description: 'Port the HTTP server listens on',\n      short: 'p',\n      default: agentDefaults.port,\n    },\n    host: {\n      type: 'string',\n      description: 'Hostname the HTTP server binds to',\n      default: agentDefaults.host,\n    },\n    'allow-write': {\n      type: 'boolean',\n      description: 'Write generated files to the filesystem. When omitted, output is streamed only and no files are written.',\n      default: false,\n    },\n    'allow-all': {\n      type: 'boolean',\n      description: 'Grant all permissions (implies --allow-write).',\n      default: false,\n    },\n  },\n  async run({ values }) {\n    const { runAgentStart } = await import('../../runners/agent.ts')\n\n    await runAgentStart({\n      port: values.port !== undefined ? values.port : undefined,\n      host: values.host,\n      configPath: values.config,\n      allowWrite: values['allow-write'],\n      allowAll: values['allow-all'],\n      version,\n    })\n  },\n})\n","import { defineCommand } from '@internals/utils'\nimport { command as startCommand } from './agent/start.ts'\n\nexport const command = defineCommand({\n  name: 'agent',\n  description:\n    'Manage the Kubb Agent — an HTTP server that lets AI agents trigger code generation programmatically via a REST API. Useful when an AI workflow needs to generate code without direct CLI access.',\n  examples: ['kubb agent start', 'kubb agent start --port 4000 --allow-write', 'kubb agent start --config ./kubb.config.ts --allow-all'],\n  subCommands: [startCommand],\n})\n"],"mappings":";;;;;;ACGA,MAAa,UAAU,cAAc;CACnC,MAAM;CACN,aACE;CACF,UAAU;EAAC;EAAoB;EAA8C;EAAyD;CACtI,aAAa,CDJQ,cAAc;EACnC,MAAM;EACN,aACE;EACF,UAAU;GAAC;GAAoB;GAAgC;GAAkC;GAAyD;EAC1J,SAAS;GACP,QAAQ;IACN,MAAM;IACN,aAAa;IACb,OAAO;IACR;GACD,MAAM;IACJ,MAAM;IACN,aAAa;IACb,OAAO;IACP,SAAS,cAAc;IACxB;GACD,MAAM;IACJ,MAAM;IACN,aAAa;IACb,SAAS,cAAc;IACxB;GACD,eAAe;IACb,MAAM;IACN,aAAa;IACb,SAAS;IACV;GACD,aAAa;IACX,MAAM;IACN,aAAa;IACb,SAAS;IACV;GACF;EACD,MAAM,IAAI,EAAE,UAAU;GACpB,MAAM,EAAE,kBAAkB,MAAM,OAAO;GAEvC,MAAM,cAAc;IAClB,MAAM,OAAO,SAAS,KAAA,IAAY,OAAO,OAAO,KAAA;IAChD,MAAM,OAAO;IACb,YAAY,OAAO;IACnB,YAAY,OAAO;IACnB,UAAU,OAAO;IACjB;IACD,CAAC;;EAEL,CCzCeC,CAAa;CAC5B,CAAC"}

package/dist/agent-CXNO6dgj.cjs

@@ -1,70 +0,0 @@
-require("./chunk-ByKO4r7w.cjs");
-const require_define = require("./define-Bdn8j5VM.cjs");
-const require_package = require("./package-iheSdfas.cjs");
-const require_constants = require("./constants-Rcaqzyd-.cjs");
-//#region src/commands/agent/start.ts
-const command$1 = require_define.defineCommand({
-	name: "start",
-	description: "Start the Kubb Agent HTTP server. Exposes a REST API that accepts a kubb.config.ts patch and returns generated code as a stream. Use --allow-write to also write files to disk.",
-	examples: [
-		"kubb agent start",
-		"kubb agent start --port 4000",
-		"kubb agent start --allow-write",
-		"kubb agent start --config ./kubb.config.ts --allow-all"
-	],
-	options: {
-		config: {
-			type: "string",
-			description: "Path to the Kubb config file",
-			short: "c"
-		},
-		port: {
-			type: "string",
-			description: "Port the HTTP server listens on",
-			short: "p",
-			default: require_constants.agentDefaults.port
-		},
-		host: {
-			type: "string",
-			description: "Hostname the HTTP server binds to",
-			default: require_constants.agentDefaults.host
-		},
-		"allow-write": {
-			type: "boolean",
-			description: "Write generated files to the filesystem. When omitted, output is streamed only and no files are written.",
-			default: false
-		},
-		"allow-all": {
-			type: "boolean",
-			description: "Grant all permissions (implies --allow-write).",
-			default: false
-		}
-	},
-	async run({ values }) {
-		const { runAgentStart } = await Promise.resolve().then(() => require("./agent-D9CKYh4K.cjs"));
-		await runAgentStart({
-			port: values.port !== void 0 ? values.port : void 0,
-			host: values.host,
-			configPath: values.config,
-			allowWrite: values["allow-write"],
-			allowAll: values["allow-all"],
-			version: require_package.version
-		});
-	}
-});
-//#endregion
-//#region src/commands/agent.ts
-const command = require_define.defineCommand({
-	name: "agent",
-	description: "Manage the Kubb Agent — an HTTP server that lets AI agents trigger code generation programmatically via a REST API. Useful when an AI workflow needs to generate code without direct CLI access.",
-	examples: [
-		"kubb agent start",
-		"kubb agent start --port 4000 --allow-write",
-		"kubb agent start --config ./kubb.config.ts --allow-all"
-	],
-	subCommands: [command$1]
-});
-//#endregion
-exports.command = command;
-
-//# sourceMappingURL=agent-CXNO6dgj.cjs.map

package/dist/agent-CXNO6dgj.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"agent-CXNO6dgj.cjs","names":["command","defineCommand","agentDefaults","defineCommand","startCommand"],"sources":["../src/commands/agent/start.ts","../src/commands/agent.ts"],"sourcesContent":["import { defineCommand } from '@internals/utils'\nimport { version } from '../../../package.json'\nimport { agentDefaults } from '../../constants.ts'\n\nexport const command = defineCommand({\n  name: 'start',\n  description:\n    'Start the Kubb Agent HTTP server. Exposes a REST API that accepts a kubb.config.ts patch and returns generated code as a stream. Use --allow-write to also write files to disk.',\n  examples: ['kubb agent start', 'kubb agent start --port 4000', 'kubb agent start --allow-write', 'kubb agent start --config ./kubb.config.ts --allow-all'],\n  options: {\n    config: {\n      type: 'string',\n      description: 'Path to the Kubb config file',\n      short: 'c',\n    },\n    port: {\n      type: 'string',\n      description: 'Port the HTTP server listens on',\n      short: 'p',\n      default: agentDefaults.port,\n    },\n    host: {\n      type: 'string',\n      description: 'Hostname the HTTP server binds to',\n      default: agentDefaults.host,\n    },\n    'allow-write': {\n      type: 'boolean',\n      description: 'Write generated files to the filesystem. When omitted, output is streamed only and no files are written.',\n      default: false,\n    },\n    'allow-all': {\n      type: 'boolean',\n      description: 'Grant all permissions (implies --allow-write).',\n      default: false,\n    },\n  },\n  async run({ values }) {\n    const { runAgentStart } = await import('../../runners/agent.ts')\n\n    await runAgentStart({\n      port: values.port !== undefined ? values.port : undefined,\n      host: values.host,\n      configPath: values.config,\n      allowWrite: values['allow-write'],\n      allowAll: values['allow-all'],\n      version,\n    })\n  },\n})\n","import { defineCommand } from '@internals/utils'\nimport { command as startCommand } from './agent/start.ts'\n\nexport const command = defineCommand({\n  name: 'agent',\n  description:\n    'Manage the Kubb Agent — an HTTP server that lets AI agents trigger code generation programmatically via a REST API. Useful when an AI workflow needs to generate code without direct CLI access.',\n  examples: ['kubb agent start', 'kubb agent start --port 4000 --allow-write', 'kubb agent start --config ./kubb.config.ts --allow-all'],\n  subCommands: [startCommand],\n})\n"],"mappings":";;;;;AAIA,MAAaA,YAAUC,eAAAA,cAAc;CACnC,MAAM;CACN,aACE;CACF,UAAU;EAAC;EAAoB;EAAgC;EAAkC;EAAyD;CAC1J,SAAS;EACP,QAAQ;GACN,MAAM;GACN,aAAa;GACb,OAAO;GACR;EACD,MAAM;GACJ,MAAM;GACN,aAAa;GACb,OAAO;GACP,SAASC,kBAAAA,cAAc;GACxB;EACD,MAAM;GACJ,MAAM;GACN,aAAa;GACb,SAASA,kBAAAA,cAAc;GACxB;EACD,eAAe;GACb,MAAM;GACN,aAAa;GACb,SAAS;GACV;EACD,aAAa;GACX,MAAM;GACN,aAAa;GACb,SAAS;GACV;EACF;CACD,MAAM,IAAI,EAAE,UAAU;EACpB,MAAM,EAAE,kBAAkB,MAAA,QAAA,SAAA,CAAA,WAAA,QAAM,uBAAA,CAAA;EAEhC,MAAM,cAAc;GAClB,MAAM,OAAO,SAAS,KAAA,IAAY,OAAO,OAAO,KAAA;GAChD,MAAM,OAAO;GACb,YAAY,OAAO;GACnB,YAAY,OAAO;GACnB,UAAU,OAAO;GACjB,SAAA,gBAAA;GACD,CAAC;;CAEL,CAAC;;;AC9CF,MAAa,UAAUC,eAAAA,cAAc;CACnC,MAAM;CACN,aACE;CACF,UAAU;EAAC;EAAoB;EAA8C;EAAyD;CACtI,aAAa,CAACC,UAAa;CAC5B,CAAC"}

package/dist/agent-D9CKYh4K.cjs

@@ -1,122 +0,0 @@
-const require_chunk = require("./chunk-ByKO4r7w.cjs");
-const require_telemetry = require("./telemetry-BLX0NzRk.cjs");
-const require_shell = require("./shell-475fQKaX.cjs");
-const require_constants = require("./constants-Rcaqzyd-.cjs");
-let node_util = require("node:util");
-let node_path = require("node:path");
-node_path = require_chunk.__toESM(node_path, 1);
-let node_process = require("node:process");
-node_process = require_chunk.__toESM(node_process, 1);
-let node_net = require("node:net");
-node_net = require_chunk.__toESM(node_net, 1);
-let node_url = require("node:url");
-let _clack_prompts = require("@clack/prompts");
-_clack_prompts = require_chunk.__toESM(_clack_prompts, 1);
-//#region src/runners/agent.ts
-/**
-* Resolves the environment passed to the detached agent process using CLI values first, then environment values, then CLI defaults.
-*/
-function resolveAgentStartEnvironment({ port, host, configPath, allowWrite, allowAll }) {
-	const resolvedPort = port ?? node_process.env.PORT ?? require_constants.agentDefaults.port;
-	const resolvedHost = host !== require_constants.agentDefaults.host ? host : node_process.env.HOST ?? require_constants.agentDefaults.host;
-	const resolvedAllowAll = allowAll || node_process.env.KUBB_AGENT_ALLOW_ALL === "true";
-	const resolvedAllowWrite = resolvedAllowAll || allowWrite || node_process.env.KUBB_AGENT_ALLOW_WRITE === "true";
-	const agentRoot = node_process.env.KUBB_AGENT_ROOT ?? node_process.cwd();
-	const agentConfigPath = node_path.default.resolve(node_process.cwd(), configPath || node_process.env.KUBB_AGENT_CONFIG || require_constants.agentDefaults.configFile);
-	return {
-		port: resolvedPort,
-		host: resolvedHost,
-		allowWrite: resolvedAllowWrite,
-		allowAll: resolvedAllowAll,
-		agentConfigPath,
-		env: {
-			...node_process.env,
-			PORT: resolvedPort,
-			HOST: resolvedHost,
-			KUBB_AGENT_ROOT: agentRoot,
-			KUBB_AGENT_CONFIG: agentConfigPath,
-			KUBB_AGENT_ALLOW_WRITE: String(resolvedAllowWrite),
-			KUBB_AGENT_ALLOW_ALL: String(resolvedAllowAll),
-			KUBB_AGENT_TOKEN: node_process.env.KUBB_AGENT_TOKEN,
-			KUBB_AGENT_RETRY_TIMEOUT: node_process.env.KUBB_AGENT_RETRY_TIMEOUT ?? require_constants.agentDefaults.retryTimeout,
-			KUBB_STUDIO_URL: node_process.env.KUBB_STUDIO_URL ?? require_constants.agentDefaults.studioUrl
-		}
-	};
-}
-function isPortAvailable(port, host) {
-	return new Promise((resolve) => {
-		const server = node_net.default.createServer();
-		server.once("error", () => resolve(false));
-		server.once("listening", () => {
-			server.close();
-			resolve(true);
-		});
-		server.listen(port, host);
-	});
-}
-async function runAgentStart({ port, host, configPath, allowWrite, allowAll, version }) {
-	const hrStart = node_process.hrtime();
-	try {
-		try {
-			node_process.loadEnvFile();
-		} catch {}
-		let agentPkgUrl;
-		try {
-			agentPkgUrl = {}.resolve("@kubb/agent/package.json");
-		} catch (_e) {
-			console.error((0, node_util.styleText)("red", "The @kubb/agent package is not installed."));
-			console.error("");
-			console.error("Install it with:");
-			console.error((0, node_util.styleText)("cyan", "  npm install @kubb/agent"));
-			console.error((0, node_util.styleText)("cyan", "  # or"));
-			console.error((0, node_util.styleText)("cyan", "  pnpm install @kubb/agent"));
-			console.error("");
-			node_process.exit(1);
-		}
-		const agentPkgPath = (0, node_url.fileURLToPath)(agentPkgUrl);
-		const agentDir = node_path.default.dirname(agentPkgPath);
-		const serverPath = node_path.default.join(agentDir, require_constants.agentDefaults.serverEntryPath);
-		const resolvedEnv = resolveAgentStartEnvironment({
-			port,
-			host,
-			configPath,
-			allowWrite,
-			allowAll
-		});
-		const numericPort = Number(resolvedEnv.port);
-		if (!Number.isInteger(numericPort) || numericPort <= 0) throw new Error(`Invalid port "${resolvedEnv.port}". Provide a positive integer with --port or PORT.`);
-		_clack_prompts.log.step((0, node_util.styleText)("cyan", "Starting agent server..."));
-		_clack_prompts.log.info((0, node_util.styleText)("dim", `Config: ${resolvedEnv.agentConfigPath}`));
-		_clack_prompts.log.info((0, node_util.styleText)("dim", `Host: ${resolvedEnv.host}`));
-		_clack_prompts.log.info((0, node_util.styleText)("dim", `Port: ${resolvedEnv.port}`));
-		if (!resolvedEnv.allowWrite && !resolvedEnv.allowAll) _clack_prompts.log.warn((0, node_util.styleText)("yellow", "Filesystem writes disabled. Use --allow-write or --allow-all to enable."));
-		if (!await isPortAvailable(numericPort, resolvedEnv.host)) {
-			_clack_prompts.log.error((0, node_util.styleText)("red", `Port ${resolvedEnv.port} is already in use. Stop the existing process or choose a different port with --port.`));
-			node_process.exit(1);
-		}
-		await require_shell.spawnAsync("node", [serverPath], {
-			env: resolvedEnv.env,
-			cwd: node_process.cwd()
-		});
-		await require_telemetry.sendTelemetry(require_telemetry.buildTelemetryEvent({
-			command: "agent",
-			kubbVersion: version,
-			hrStart,
-			status: "success"
-		}));
-	} catch (error) {
-		await require_telemetry.sendTelemetry(require_telemetry.buildTelemetryEvent({
-			command: "agent",
-			kubbVersion: version,
-			hrStart,
-			status: "failed"
-		}));
-		_clack_prompts.log.error((0, node_util.styleText)("red", "Failed to start agent server"));
-		console.error(error);
-		node_process.exit(1);
-	}
-}
-//#endregion
-exports.runAgentStart = runAgentStart;
-
-//# sourceMappingURL=agent-D9CKYh4K.cjs.map