@kubb/cli 4.32.4 → 4.33.0

package/src/runners/init.ts

@@ -0,0 +1,322 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import process from 'node:process'
+import { styleText } from 'node:util'
+import * as clack from '@clack/prompts'
+import { detectPackageManager, type PackageManagerInfo } from '@kubb/core'
+import { initDefaults, pluginDefaultConfigs } from '../constants.ts'
+import { hasPackageJson, initPackageJson, installPackages } from '../utils/packageManager.ts'
+
+type PluginOption = {
+  value: string
+  label: string
+  hint?: string
+  packageName: string
+  importName: string
+  category: 'core' | 'typescript' | 'query' | 'validation' | 'testing' | 'mocking' | 'docs'
+}
+
+const availablePlugins: PluginOption[] = [
+  {
+    value: 'plugin-oas',
+    label: 'OpenAPI Parser',
+    hint: 'Required',
+    packageName: '@kubb/plugin-oas',
+    importName: 'pluginOas',
+    category: 'core',
+  },
+  {
+    value: 'plugin-ts',
+    label: 'TypeScript',
+    hint: 'Recommended',
+    packageName: '@kubb/plugin-ts',
+    importName: 'pluginTs',
+    category: 'typescript',
+  },
+  {
+    value: 'plugin-client',
+    label: 'Client (Fetch/Axios)',
+    packageName: '@kubb/plugin-client',
+    importName: 'pluginClient',
+    category: 'typescript',
+  },
+  {
+    value: 'plugin-react-query',
+    label: 'React Query / TanStack Query',
+    packageName: '@kubb/plugin-react-query',
+    importName: 'pluginReactQuery',
+    category: 'query',
+  },
+  {
+    value: 'plugin-solid-query',
+    label: 'Solid Query',
+    packageName: '@kubb/plugin-solid-query',
+    importName: 'pluginSolidQuery',
+    category: 'query',
+  },
+  {
+    value: 'plugin-svelte-query',
+    label: 'Svelte Query',
+    packageName: '@kubb/plugin-svelte-query',
+    importName: 'pluginSvelteQuery',
+    category: 'query',
+  },
+  {
+    value: 'plugin-vue-query',
+    label: 'Vue Query',
+    packageName: '@kubb/plugin-vue-query',
+    importName: 'pluginVueQuery',
+    category: 'query',
+  },
+  {
+    value: 'plugin-swr',
+    label: 'SWR',
+    packageName: '@kubb/plugin-swr',
+    importName: 'pluginSwr',
+    category: 'query',
+  },
+  {
+    value: 'plugin-zod',
+    label: 'Zod Schemas',
+    packageName: '@kubb/plugin-zod',
+    importName: 'pluginZod',
+    category: 'validation',
+  },
+  {
+    value: 'plugin-faker',
+    label: 'Faker.js Mocks',
+    packageName: '@kubb/plugin-faker',
+    importName: 'pluginFaker',
+    category: 'mocking',
+  },
+  {
+    value: 'plugin-msw',
+    label: 'MSW Handlers',
+    packageName: '@kubb/plugin-msw',
+    importName: 'pluginMsw',
+    category: 'mocking',
+  },
+  {
+    value: 'plugin-cypress',
+    label: 'Cypress Tests',
+    packageName: '@kubb/plugin-cypress',
+    importName: 'pluginCypress',
+    category: 'testing',
+  },
+  {
+    value: 'plugin-redoc',
+    label: 'ReDoc Documentation',
+    packageName: '@kubb/plugin-redoc',
+    importName: 'pluginRedoc',
+    category: 'docs',
+  },
+]
+
+function generateConfigFile(selectedPlugins: PluginOption[], inputPath: string, outputPath: string): string {
+  const imports = selectedPlugins.map((plugin) => `import { ${plugin.importName} } from '${plugin.packageName}'`).join('\n')
+
+  const pluginConfigs = selectedPlugins
+    .map((plugin) => {
+      const config = (pluginDefaultConfigs as Record<string, string>)[plugin.value] ?? `${plugin.importName}()`
+      return `    ${config},`
+    })
+    .join('\n')
+
+  return `import { defineConfig } from '@kubb/core'
+${imports}
+
+export default defineConfig({
+  root: '.',
+  input: {
+    path: '${inputPath}',
+  },
+  output: {
+    path: '${outputPath}',
+    clean: true,
+  },
+  plugins: [
+${pluginConfigs}
+  ],
+})
+`
+}
+
+function cancelAndExit(message = 'Operation cancelled.'): never {
+  clack.cancel(message)
+  process.exit(0)
+}
+
+type InitOptions = {
+  yes: boolean
+  version: string
+}
+
+export async function runInit({ yes, version }: InitOptions): Promise<void> {
+  const cwd = process.cwd()
+
+  clack.intro(styleText('bgCyan', styleText('black', ' Kubb Init ')))
+
+  try {
+    // Check/create package.json
+    let packageManager: PackageManagerInfo
+    if (!hasPackageJson(cwd)) {
+      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()
+        }
+      }
+
+      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)
+      clack.log.info(`Detected package manager: ${styleText('cyan', packageManager.name)}`)
+    }
+
+    // Prompt for OpenAPI spec path
+    let inputPath: string
+    if (yes) {
+      inputPath = initDefaults.inputPath
+      clack.log.info(`Using input path: ${styleText('cyan', inputPath)}`)
+    } else {
+      const inputPathResult = await 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 (yes) {
+      outputPath = initDefaults.outputPath
+      clack.log.info(`Using output path: ${styleText('cyan', outputPath)}`)
+    } else {
+      const outputPathResult = await 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 (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({
+        message: 'Select plugins to use:',
+        options: availablePlugins.map((plugin) => ({
+          value: plugin.value,
+          label: plugin.label,
+          hint: plugin.hint,
+        })),
+        initialValues: [...initDefaults.plugins],
+        required: true,
+      })
+
+      if (clack.isCancel(selectedPluginValues)) {
+        cancelAndExit()
+      }
+
+      selectedPlugins = availablePlugins.filter((plugin) => (selectedPluginValues as string[]).includes(plugin.value))
+    }
+
+    // Ensure plugin-oas is always included
+    if (!selectedPlugins.find((p) => p.value === 'plugin-oas')) {
+      selectedPlugins.unshift(availablePlugins.find((p) => p.value === 'plugin-oas')!)
+    }
+
+    // Install packages
+    const packagesToInstall = ['@kubb/core', '@kubb/cli', '@kubb/agent', ...selectedPlugins.map((p) => p.packageName)]
+
+    const spinner = clack.spinner()
+    spinner.start(`Installing ${packagesToInstall.length} packages with ${packageManager.name}`)
+
+    try {
+      await installPackages(packagesToInstall, packageManager, cwd)
+      spinner.stop(`Installed ${packagesToInstall.length} packages`)
+    } catch (error) {
+      spinner.stop('Installation failed')
+      throw error
+    }
+
+    // Generate config file
+    const configSpinner = clack.spinner()
+    configSpinner.start('Creating kubb.config.ts')
+
+    const configContent = generateConfigFile(selectedPlugins, inputPath, outputPath)
+    const configPath = path.join(cwd, 'kubb.config.ts')
+
+    if (fs.existsSync(configPath)) {
+      configSpinner.stop('kubb.config.ts already exists')
+
+      if (!yes) {
+        const shouldOverwrite = await clack.confirm({
+          message: 'kubb.config.ts already exists. Overwrite?',
+          initialValue: false,
+        })
+
+        if (clack.isCancel(shouldOverwrite) || !shouldOverwrite) {
+          cancelAndExit('Keeping existing configuration. Packages have been installed.')
+        }
+      }
+
+      configSpinner.start('Overwriting kubb.config.ts')
+    }
+
+    fs.writeFileSync(configPath, configContent, 'utf-8')
+
+    configSpinner.stop('Created kubb.config.ts')
+
+    clack.outro(
+      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', '     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}`),
+    )
+  } catch (error) {
+    clack.log.error(styleText('red', 'An error occurred during initialization'))
+    if (error instanceof Error) {
+      clack.log.error(error.message)
+    }
+    process.exit(1)
+  }
+}

package/src/runners/mcp.ts

@@ -0,0 +1,32 @@
+import process from 'node:process'
+import { styleText } from 'node:util'
+import type * as McpModule from '@kubb/mcp'
+import { getErrorMessage } from '../utils/errors.ts'
+import { jiti } from '../utils/jiti.ts'
+import { buildTelemetryEvent, sendTelemetry } from '../utils/telemetry.ts'
+
+type McpOptions = {
+  version: string
+}
+
+export async function runMcp({ version }: McpOptions): Promise<void> {
+  let mod: typeof McpModule
+  try {
+    mod = (await jiti.import('@kubb/mcp', { default: true })) as typeof McpModule
+  } catch (_e) {
+    console.error(`Import of '@kubb/mcp' is required to start the MCP server`)
+    process.exit(1)
+  }
+
+  const { run } = mod
+  const hrStart = process.hrtime()
+  try {
+    console.log('⏳ Starting MCP server...')
+    console.warn(styleText('yellow', 'This feature is still under development — use with caution'))
+    run()
+    await sendTelemetry(buildTelemetryEvent({ command: 'mcp', kubbVersion: version, hrStart, status: 'success' }))
+  } catch (error) {
+    await sendTelemetry(buildTelemetryEvent({ command: 'mcp', kubbVersion: version, hrStart, status: 'failed' }))
+    console.error(getErrorMessage(error))
+  }
+}

package/src/runners/validate.ts

@@ -0,0 +1,35 @@
+import process from 'node:process'
+import type * as OasModule from '@kubb/oas'
+import { getErrorMessage } from '../utils/errors.ts'
+import { jiti } from '../utils/jiti.ts'
+import { buildTelemetryEvent, sendTelemetry } from '../utils/telemetry.ts'
+
+type ValidateOptions = {
+  input: string
+  version: string
+}
+
+export async function runValidate({ input, version }: ValidateOptions): Promise<void> {
+  let mod: typeof OasModule
+  try {
+    mod = (await jiti.import('@kubb/oas', { default: true })) as typeof OasModule
+  } catch (_e) {
+    console.error(`Import of '@kubb/oas' is required to do validation`)
+    process.exit(1)
+  }
+
+  const { parse } = mod
+  const hrStart = process.hrtime()
+  try {
+    const oas = await parse(input)
+    await oas.validate()
+
+    await sendTelemetry(buildTelemetryEvent({ command: 'validate', kubbVersion: version, hrStart, status: 'success' }))
+    console.log('✅ Validation success')
+  } catch (error) {
+    await sendTelemetry(buildTelemetryEvent({ command: 'validate', kubbVersion: version, hrStart, status: 'failed' }))
+    console.error('❌ Validation failed')
+    console.error(getErrorMessage(error))
+    process.exit(1)
+  }
+}

package/src/utils/Writables.ts

@@ -10,8 +10,8 @@ export class ClackWritable extends Writable {
 
     this.taskLog = taskLog
   }
-  _write(chunk: any, _encoding: BufferEncoding, callback: (error?: Error | null) => void): void {
-    this.taskLog.message(`${styleText('dim', chunk?.toString())}`)
+  _write(chunk: Buffer, _encoding: BufferEncoding, callback: (error?: Error | null) => void): void {
+    this.taskLog.message(`${styleText('dim', chunk.toString())}`)
     callback()
   }
 }

package/src/utils/envDetection.ts

@@ -0,0 +1,34 @@
+/**
+ * Check if running in GitHub Actions environment
+ */
+export function isGitHubActions(): boolean {
+  return !!process.env.GITHUB_ACTIONS
+}
+
+/**
+ * Check if running in any CI environment.
+ * Covers all major CI systems via their well-known environment variables.
+ */
+export function isCIEnvironment(): boolean {
+  return !!(
+    (
+      process.env.CI || // Generic (GitHub Actions, GitLab CI, CircleCI, Travis CI, etc.)
+      process.env.GITHUB_ACTIONS || // GitHub Actions
+      process.env.GITLAB_CI || // GitLab CI
+      process.env.BITBUCKET_BUILD_NUMBER || // Bitbucket Pipelines
+      process.env.JENKINS_URL || // Jenkins
+      process.env.CIRCLECI || // CircleCI
+      process.env.TRAVIS || // Travis CI
+      process.env.TEAMCITY_VERSION || // TeamCity
+      process.env.BUILDKITE || // Buildkite
+      process.env.TF_BUILD
+    ) // Azure Pipelines
+  )
+}
+
+/**
+ * Check if TTY is available for interactive output
+ */
+export function canUseTTY(): boolean {
+  return !!process.stdout.isTTY && !isCIEnvironment()
+}

package/src/utils/errors.ts

@@ -0,0 +1,23 @@
+/**
+ * Coerce an unknown thrown value to an `Error` instance.
+ * When the value is already an `Error` it is returned as-is;
+ * otherwise a new `Error` is created whose message is `String(value)`.
+ */
+export function toError(value: unknown): Error {
+  return value instanceof Error ? value : new Error(String(value))
+}
+
+/**
+ * Safely extract a human-readable message from any thrown value.
+ */
+export function getErrorMessage(value: unknown): string {
+  return value instanceof Error ? value.message : String(value)
+}
+
+/**
+ * Extract the `.cause` property of an `Error` as an `Error | undefined`.
+ * Returns `undefined` when the cause is absent or is not an `Error`.
+ */
+export function toCause(error: Error): Error | undefined {
+  return error.cause instanceof Error ? error.cause : undefined
+}

package/src/utils/executeHooks.ts

@@ -20,14 +20,26 @@ export async function executeHooks({ hooks, events }: ExecutingHooksProps): Prom
     }
 
     const hookId = createHash('sha256').update(command).digest('hex')
-    await events.emit('hook:start', { id: hookId, command: cmd, args })
 
-    await events.onOnce('hook:end', async ({ success, error }) => {
-      if (!success) {
-        throw error
+    // Wire up the hook:end listener BEFORE emitting hook:start to avoid the race condition
+    // where hook:end fires synchronously inside emit('hook:start') before the listener is registered.
+    const hookEndPromise = new Promise<void>((resolve, reject) => {
+      const handler = ({ id, success, error }: { id?: string; command: string; args?: readonly string[]; success: boolean; error: Error | null }) => {
+        if (id !== hookId) return
+        events.off('hook:end', handler)
+        if (!success) {
+          reject(error ?? new Error(`Hook failed: ${command}`))
+          return
+        }
+        events
+          .emit('success', `${styleText('dim', command)} successfully executed`)
+          .then(resolve)
+          .catch(reject)
       }
-
-      await events.emit('success', `${styleText('dim', command)} successfully executed`)
+      events.on('hook:end', handler)
     })
+
+    await events.emit('hook:start', { id: hookId, command: cmd, args })
+    await hookEndPromise
   }
 }

package/src/utils/getCosmiConfig.ts

@@ -2,24 +2,23 @@ import type { defineConfig, UserConfig } from '@kubb/core'
 import { cosmiconfig } from 'cosmiconfig'
 import { createJiti } from 'jiti'
 
-export type CosmiconfigResult = {
+type CosmiconfigResult = {
   filepath: string
   isEmpty?: boolean
   config: ReturnType<typeof defineConfig> | UserConfig
 }
 
-const tsLoader = async (configFile: string) => {
-  const jiti = createJiti(import.meta.url, {
-    jsx: {
-      runtime: 'automatic',
-      importSource: '@kubb/react-fabric',
-    },
-    sourceMaps: true,
-    interopDefault: true,
-  })
+const jiti = createJiti(import.meta.url, {
+  jsx: {
+    runtime: 'automatic',
+    importSource: '@kubb/react-fabric',
+  },
+  sourceMaps: true,
+  interopDefault: true,
+})
 
+const tsLoader = async (configFile: string) => {
   const mod = await jiti.import(configFile, { default: true })
-
   return mod
 }
 

package/src/utils/getIntro.ts

@@ -5,28 +5,27 @@ import { styleText } from 'node:util'
  * Supports hex color codes without external dependencies like chalk
  */
 
+/** Parse a hex color string into RGB components, defaulting to 255 on invalid input. */
+function parseHex(color: string): { r: number; g: number; b: number } {
+  const c = color.replace('#', '')
+  const r = Number.parseInt(c.slice(0, 2), 16)
+  const g = Number.parseInt(c.slice(2, 4), 16)
+  const b = Number.parseInt(c.slice(4, 6), 16)
+  return {
+    r: Number.isNaN(r) ? 255 : r,
+    g: Number.isNaN(g) ? 255 : g,
+    b: Number.isNaN(b) ? 255 : b,
+  }
+}
+
 /**
  * Convert hex color to ANSI 24-bit true color escape sequence
  * @param color - Hex color code (with or without #), e.g., '#FF5500' or 'FF5500'
  * @returns Function that wraps text with the color
  */
 function hex(color: string): (text: string) => string {
-  const cleanHex = color.replace('#', '')
-  const r = Number.parseInt(cleanHex.slice(0, 2), 16)
-  const g = Number.parseInt(cleanHex.slice(2, 4), 16)
-  const b = Number.parseInt(cleanHex.slice(4, 6), 16)
-
-  // Default to white (255) if parsing fails (NaN)
-  const safeR = Number.isNaN(r) ? 255 : r
-  const safeG = Number.isNaN(g) ? 255 : g
-  const safeB = Number.isNaN(b) ? 255 : b
-
-  return (text: string) => `\x1b[38;2;${safeR};${safeG};${safeB}m${text}\x1b[0m`
-}
-
-function hexToRgb(color: string) {
-  const c = color.replace('#', '')
-  return { r: Number.parseInt(c.slice(0, 2), 16), g: Number.parseInt(c.slice(2, 4), 16), b: Number.parseInt(c.slice(4, 6), 16) }
+  const { r, g, b } = parseHex(color)
+  return (text: string) => `\x1b[38;2;${r};${g};${b}m${text}\x1b[0m`
 }
 
 function gradient(colors: string[]) {
@@ -37,8 +36,8 @@ function gradient(colors: string[]) {
         const t = chars.length <= 1 ? 0 : i / (chars.length - 1)
         const seg = Math.min(Math.floor(t * (colors.length - 1)), colors.length - 2)
         const lt = t * (colors.length - 1) - seg
-        const from = hexToRgb(colors[seg]!)
-        const to = hexToRgb(colors[seg + 1]!)
+        const from = parseHex(colors[seg]!)
+        const to = parseHex(colors[seg + 1]!)
         const r = Math.round(from.r + (to.r - from.r) * lt)
         const g = Math.round(from.g + (to.g - from.g) * lt)
         const b = Math.round(from.b + (to.b - from.b) * lt)

package/src/utils/getSummary.ts

@@ -2,6 +2,7 @@ import path from 'node:path'
 import { styleText } from 'node:util'
 import type { Config, Plugin } from '@kubb/core'
 import { formatHrtime } from '@kubb/core/utils'
+import { SUMMARY_MAX_BAR_LENGTH, SUMMARY_TIME_SCALE_DIVISOR } from '../constants.ts'
 import { randomCliColor } from './randomColor.ts'
 
 type SummaryProps = {
@@ -16,7 +17,7 @@ type SummaryProps = {
 export function getSummary({ failedPlugins, filesCreated, status, hrStart, config, pluginTimings }: SummaryProps): string[] {
   const duration = formatHrtime(hrStart)
 
-  const pluginsCount = config.plugins?.length || 0
+  const pluginsCount = config.plugins?.length ?? 0
   const successCount = pluginsCount - failedPlugins.size
 
   const meta = {
@@ -24,8 +25,8 @@ export function getSummary({ failedPlugins, filesCreated, status, hrStart, confi
       status === 'success'
         ? `${styleText('green', `${successCount} successful`)}, ${pluginsCount} total`
         : `${styleText('green', `${successCount} successful`)}, ${styleText('red', `${failedPlugins.size} failed`)}, ${pluginsCount} total`,
-    pluginsFailed: status === 'failed' ? [...failedPlugins]?.map(({ plugin }) => randomCliColor(plugin.name))?.join(', ') : undefined,
-    filesCreated: filesCreated,
+    pluginsFailed: status === 'failed' ? [...failedPlugins].map(({ plugin }) => randomCliColor(plugin.name)).join(', ') : undefined,
+    filesCreated,
     time: styleText('green', duration),
     output: path.isAbsolute(config.root) ? path.resolve(config.root, config.output.path) : config.root,
   } as const
@@ -49,22 +50,17 @@ export function getSummary({ failedPlugins, filesCreated, status, hrStart, confi
   summaryLines.push(`${labels.generated.padEnd(maxLength + 2)} ${meta.filesCreated} files in ${meta.time}`)
 
   if (pluginTimings && pluginTimings.size > 0) {
-    const TIME_SCALE_DIVISOR = 100
-    const MAX_BAR_LENGTH = 10
-
     const sortedTimings = Array.from(pluginTimings.entries()).sort((a, b) => b[1] - a[1])
 
-    if (sortedTimings.length > 0) {
-      summaryLines.push(`${labels.pluginTimings}`)
+    summaryLines.push(`${labels.pluginTimings}`)
 
-      sortedTimings.forEach(([name, time]) => {
-        const timeStr = time >= 1000 ? `${(time / 1000).toFixed(2)}s` : `${Math.round(time)}ms`
-        const barLength = Math.min(Math.ceil(time / TIME_SCALE_DIVISOR), MAX_BAR_LENGTH)
-        const bar = styleText('dim', '█'.repeat(barLength))
+    sortedTimings.forEach(([name, time]) => {
+      const timeStr = time >= 1000 ? `${(time / 1000).toFixed(2)}s` : `${Math.round(time)}ms`
+      const barLength = Math.min(Math.ceil(time / SUMMARY_TIME_SCALE_DIVISOR), SUMMARY_MAX_BAR_LENGTH)
+      const bar = styleText('dim', '█'.repeat(barLength))
 
-        summaryLines.push(`${styleText('dim', '•')} ${name.padEnd(maxLength + 1)}${bar} ${timeStr}`)
-      })
-    }
+      summaryLines.push(`${styleText('dim', '•')} ${name.padEnd(maxLength + 1)}${bar} ${timeStr}`)
+    })
   }
 
   summaryLines.push(`${labels.output.padEnd(maxLength + 2)} ${meta.output}`)

package/src/utils/jiti.ts

@@ -0,0 +1,9 @@
+import { createJiti } from 'jiti'
+
+/**
+ * Shared jiti instance for dynamic ESM/TS imports across CLI commands.
+ * Created once at module scope to avoid the overhead of repeated instantiation.
+ */
+export const jiti = createJiti(import.meta.url, {
+  sourceMaps: true,
+})

package/src/utils/packageManager.ts

@@ -1,7 +1,7 @@
-import { spawn } from 'node:child_process'
 import fs from 'node:fs'
 import path from 'node:path'
 import type { PackageManagerInfo, PackageManagerName } from '@kubb/core'
+import { spawnAsync } from './spawnAsync.ts'
 
 export function hasPackageJson(cwd: string = process.cwd()): boolean {
   return fs.existsSync(path.join(cwd, 'package.json'))
@@ -15,9 +15,9 @@ export async function initPackageJson(cwd: string, packageManager: PackageManage
     bun: ['init', '-y'],
   }
 
-  spawn(packageManager.name, commands[packageManager.name], { stdio: 'inherit', cwd })
+  await spawnAsync(packageManager.name, commands[packageManager.name], { cwd })
 }
 
 export async function installPackages(packages: string[], packageManager: PackageManagerInfo, cwd: string = process.cwd()): Promise<void> {
-  spawn(packageManager.name, [...packageManager.installCommand, ...packages], { stdio: 'inherit', cwd })
+  await spawnAsync(packageManager.name, [...packageManager.installCommand, ...packages], { cwd })
 }