@kubb/cli 5.0.0-alpha.9 → 5.0.0-beta.10

package/src/runners/agent/run.ts

@@ -0,0 +1,113 @@
+import { createRequire } from 'node:module'
+import path from 'node:path'
+import process from 'node:process'
+import { styleText } from 'node:util'
+import * as clack from '@clack/prompts'
+import { spawnAsync, getErrorMessage } from '@internals/utils'
+import { agentDefaults } from '../../constants.ts'
+import { buildTelemetryEvent, sendTelemetry } from '../../telemetry.ts'
+import { isPortAvailable, resolveAgentStartEnvironment } from './utils.ts'
+
+type AgentStartOptions = {
+  /**
+   * TCP port for the HTTP server. When `undefined`, falls back to `PORT` env var or the default (`3000`).
+   */
+  port: string | undefined
+  /**
+   * Hostname the HTTP server binds to.
+   *
+   * @default 'localhost'
+   */
+  host: string
+  /**
+   * Explicit path to the Kubb config file. When `undefined`, falls back to `KUBB_AGENT_CONFIG` or the default filename.
+   */
+  configPath: string | undefined
+  /**
+   * Grants the agent permission to write generated files to the filesystem.
+   */
+  allowWrite: boolean
+  /**
+   * Grants all agent permissions, including filesystem writes. Implies `allowWrite`.
+   */
+  allowAll: boolean
+  /**
+   * Current `@kubb/cli` version string, used for the telemetry payload.
+   */
+  version: string
+}
+
+/**
+ * Spawns the Kubb Agent HTTP server as a Node.js subprocess.
+ * Resolves config from CLI flags and environment variables, validates the port, and exits with code 1 on failure.
+ */
+export async function run({ port, host, configPath, allowWrite, allowAll, version }: AgentStartOptions): Promise<void> {
+  const hrStart = process.hrtime()
+  const report = (status: 'success' | 'failed') => sendTelemetry(buildTelemetryEvent({ command: 'agent', kubbVersion: version, hrStart, status }))
+
+  try {
+    // Load .env file into process.env using Node.js built-in (v20.12.0+)
+    try {
+      process.loadEnvFile()
+    } catch {
+      // .env file may not exist; ignore
+    }
+
+    // Resolve the @kubb/agent package path — createRequire is CJS/ESM compatible (import.meta.resolve is ESM-only)
+    const require = createRequire(import.meta.url)
+    let agentPkgPath: string
+    try {
+      agentPkgPath = require.resolve('@kubb/agent/package.json')
+    } catch (_e) {
+      console.error(styleText('red', 'The @kubb/agent package is not installed.'))
+      console.error('')
+      console.error('Install it with:')
+      console.error(styleText('cyan', '  npm install @kubb/agent'))
+      console.error(styleText('cyan', '  # or'))
+      console.error(styleText('cyan', '  pnpm install @kubb/agent'))
+      console.error('')
+      process.exit(1)
+    }
+    const agentDir = path.dirname(agentPkgPath)
+    const serverPath = path.join(agentDir, 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.log.step(styleText('cyan', 'Starting agent server...'))
+    clack.log.info(styleText('dim', `Config: ${resolvedEnv.agentConfigPath}`))
+    clack.log.info(styleText('dim', `Host: ${resolvedEnv.host}`))
+    clack.log.info(styleText('dim', `Port: ${resolvedEnv.port}`))
+    if (!resolvedEnv.allowWrite && !resolvedEnv.allowAll) {
+      clack.log.warn(styleText('yellow', 'Filesystem writes disabled. Use --allow-write or --allow-all to enable.'))
+    }
+
+    if (!(await isPortAvailable(numericPort, resolvedEnv.host))) {
+      clack.log.error(styleText('red', `Port ${resolvedEnv.port} is already in use. Stop the existing process or choose a different port with --port.`))
+      process.exit(1)
+    }
+
+    // Spawns the server as a detached background process so the CLI can exit independently.
+    await spawnAsync('node', [serverPath], {
+      env: resolvedEnv.env,
+      cwd: process.cwd(),
+    })
+
+    await report('success')
+  } catch (error) {
+    await report('failed')
+    clack.log.error(styleText('red', 'Failed to start agent server'))
+    clack.log.error(getErrorMessage(error))
+    process.exit(1)
+  }
+}

package/src/runners/agent/utils.ts

@@ -0,0 +1,98 @@
+import net from 'node:net'
+import path from 'node:path'
+import process from 'node:process'
+import { agentDefaults } from '../../constants.ts'
+
+type AgentStartEnvironmentInput = {
+  /**
+   * TCP port for the HTTP server. When `undefined`, falls back to `PORT` env var or the default (`3000`).
+   */
+  port: string | undefined
+  /**
+   * Hostname the HTTP server binds to.
+   */
+  host: string
+  /**
+   * Explicit path to the Kubb config file. When `undefined`, falls back to `KUBB_AGENT_CONFIG` or the default filename.
+   */
+  configPath: string | undefined
+  /**
+   * Grants the agent permission to write generated files to the filesystem.
+   */
+  allowWrite: boolean
+  /**
+   * Grants all agent permissions, including filesystem writes. Implies `allowWrite`.
+   */
+  allowAll: boolean
+}
+
+type ResolvedAgentStartEnvironment = {
+  /**
+   * Final port string after merging CLI flag, `PORT` env var, and the default.
+   */
+  port: string
+  /**
+   * Final hostname after merging CLI flag, `HOST` env var, and the default.
+   */
+  host: string
+  /**
+   * Effective write-permission flag, accounting for `allowAll` and `KUBB_AGENT_ALLOW_WRITE`.
+   */
+  allowWrite: boolean
+  /**
+   * Effective all-permissions flag, accounting for `KUBB_AGENT_ALLOW_ALL`.
+   */
+  allowAll: boolean
+  /**
+   * Absolute path to the Kubb config file passed to the agent subprocess.
+   */
+  agentConfigPath: string
+  /**
+   * Merged `process.env` object with all resolved agent environment variables applied.
+   */
+  env: NodeJS.ProcessEnv
+}
+
+/**
+ * Resolves the environment passed to the detached agent process using CLI values first, then environment values, then CLI defaults.
+ */
+export function resolveAgentStartEnvironment({ port, host, configPath, allowWrite, allowAll }: AgentStartEnvironmentInput): ResolvedAgentStartEnvironment {
+  const resolvedPort = port ?? process.env.PORT ?? agentDefaults.port
+  const resolvedHost = host !== agentDefaults.host ? host : (process.env.HOST ?? agentDefaults.host)
+  const resolvedAllowAll = allowAll || process.env.KUBB_AGENT_ALLOW_ALL === 'true'
+  const resolvedAllowWrite = resolvedAllowAll || allowWrite || process.env.KUBB_AGENT_ALLOW_WRITE === 'true'
+  const agentRoot = process.env.KUBB_AGENT_ROOT ?? process.cwd()
+  const agentConfigPath = path.resolve(process.cwd(), configPath || process.env.KUBB_AGENT_CONFIG || agentDefaults.configFile)
+
+  return {
+    port: resolvedPort,
+    host: resolvedHost,
+    allowWrite: resolvedAllowWrite,
+    allowAll: resolvedAllowAll,
+    agentConfigPath,
+    env: {
+      ...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: process.env.KUBB_AGENT_TOKEN,
+      KUBB_AGENT_RETRY_TIMEOUT: process.env.KUBB_AGENT_RETRY_TIMEOUT ?? agentDefaults.retryTimeout,
+      KUBB_STUDIO_URL: process.env.KUBB_STUDIO_URL ?? agentDefaults.studioUrl,
+    },
+  }
+}
+
+export function isPortAvailable(port: number, host: string): Promise<boolean> {
+  return new Promise((resolve) => {
+    const server = net.createServer()
+    server.once('error', () => resolve(false))
+    server.once('listening', () => {
+      server.close()
+      resolve(true)
+    })
+    server.listen(port, host)
+  })
+}

package/src/runners/generate/run.ts

@@ -0,0 +1,276 @@
+import { createHash } from 'node:crypto'
+import path from 'node:path'
+import process from 'node:process'
+import { styleText } from 'node:util'
+import * as clack from '@clack/prompts'
+import type { AsyncEventEmitter } from '@internals/utils'
+import { AsyncEventEmitter as AsyncEventEmitterClass, detectFormatter, detectLinter, executeIfOnline, formatters, linters, toError } from '@internals/utils'
+import { type Config, createKubb, isInputPath, type KubbHooks, logLevel as logLevelMap } from '@kubb/core'
+import { version } from '../../../package.json'
+import { KUBB_NPM_PACKAGE_URL } from '../../constants.ts'
+import { setupLogger, type HookSinkFactory } from '../../loggers/utils.ts'
+import { buildTelemetryEvent, sendTelemetry } from '../../telemetry.ts'
+import { executeHooks, getConfigs, startWatcher } from './utils.ts'
+
+type GenerateProps = {
+  input?: string
+  config: Config
+  hooks: AsyncEventEmitter<KubbHooks>
+  logLevel: number
+  makeSink?: HookSinkFactory
+}
+
+type ToolMap = typeof formatters | typeof linters
+
+type RunToolPassOptions = {
+  toolValue: string
+  detect: () => Promise<string | null>
+  toolMap: ToolMap
+  toolLabel: string
+  successPrefix: string
+  noToolMessage: string
+  configName: string | undefined
+  outputPath: string
+  logLevel: number
+  hooks: AsyncEventEmitter<KubbHooks>
+  onStart: () => Promise<void>
+  onEnd: () => Promise<void>
+}
+
+/**
+ * Registers a one-shot `kubb:hook:end` listener for `hookId` BEFORE the caller emits `kubb:hook:start`,
+ * avoiding the race where a synchronous emitter fires end before the listener is attached.
+ */
+function waitForHookEnd(hooks: AsyncEventEmitter<KubbHooks>, hookId: string, onSuccess: () => Promise<void>, fallbackErrorMessage: string): Promise<void> {
+  return new Promise<void>((resolve, reject) => {
+    const handler = (ctx: { id?: string; command: string; args?: readonly string[]; success: boolean; error: Error | null }) => {
+      if (ctx.id !== hookId) return
+      hooks.off('kubb:hook:end', handler)
+      if (!ctx.success) {
+        reject(ctx.error ?? new Error(fallbackErrorMessage))
+        return
+      }
+      onSuccess().then(resolve).catch(reject)
+    }
+    hooks.on('kubb:hook:end', handler)
+  })
+}
+
+async function runToolPass({
+  toolValue,
+  detect,
+  toolMap,
+  toolLabel,
+  successPrefix,
+  noToolMessage,
+  configName,
+  outputPath,
+  logLevel,
+  hooks,
+  onStart,
+  onEnd,
+}: RunToolPassOptions) {
+  await onStart()
+
+  let resolvedTool = toolValue
+  if (resolvedTool === 'auto') {
+    const detected = await detect()
+    if (!detected) {
+      await hooks.emit('kubb:warn', { message: noToolMessage })
+    } else {
+      resolvedTool = detected
+      await hooks.emit('kubb:info', { message: `Auto-detected ${toolLabel}: ${styleText('dim', resolvedTool)}` })
+    }
+  }
+
+  let toolError: Error | undefined
+
+  if (resolvedTool && resolvedTool !== 'auto' && resolvedTool in toolMap) {
+    const toolConfig = toolMap[resolvedTool as keyof ToolMap]
+    const hookId = createHash('sha256').update([configName, resolvedTool].filter(Boolean).join('-')).digest('hex')
+
+    const successMessage = [
+      `${successPrefix} with ${styleText('dim', resolvedTool)}`,
+      logLevel >= logLevelMap.info ? `on ${styleText('dim', outputPath)}` : undefined,
+      'successfully',
+    ]
+      .filter(Boolean)
+      .join(' ')
+
+    try {
+      const hookEndPromise = waitForHookEnd(hooks, hookId, () => hooks.emit('kubb:success', { message: successMessage }), toolConfig.errorMessage)
+
+      await hooks.emit('kubb:hook:start', { id: hookId, command: toolConfig.command, args: toolConfig.args(outputPath) })
+
+      await hookEndPromise
+    } catch (caughtError) {
+      const err = toError(caughtError)
+      await hooks.emit('kubb:error', { error: err })
+      toolError = err
+    }
+  }
+
+  await onEnd()
+
+  if (toolError) {
+    throw toolError
+  }
+}
+
+async function generate(options: GenerateProps): Promise<void> {
+  const { input, hooks, logLevel, makeSink } = options
+
+  const hrStart = process.hrtime()
+  const inputPath = input ?? (options.config.input && 'path' in options.config.input ? options.config.input.path : undefined)
+
+  const config: Config = {
+    ...options.config,
+    input: inputPath ? { ...options.config.input, path: inputPath } : options.config.input,
+    ...options.config.output,
+  } satisfies Config
+
+  const kubb = createKubb(config, { hooks })
+  await kubb.setup()
+
+  await hooks.emit('kubb:generation:start', { config })
+  await hooks.emit('kubb:info', { message: config.name ? `Setup generation ${styleText('bold', config.name)}` : 'Setup generation', info: inputPath })
+  await hooks.emit('kubb:info', { message: config.name ? `Build generation ${styleText('bold', config.name)}` : 'Build generation', info: inputPath })
+
+  const { files, failedPlugins, pluginTimings, error, driver } = await kubb.safeBuild()
+
+  await hooks.emit('kubb:info', { message: 'Load summary' })
+
+  const telemetryPlugins = Array.from(driver.plugins.values(), (p) => ({ name: p.name, options: p.options as Record<string, unknown> }))
+
+  const reportTelemetry = (status: 'success' | 'failed') =>
+    sendTelemetry(buildTelemetryEvent({ command: 'generate', kubbVersion: version, plugins: telemetryPlugins, hrStart, filesCreated: files.length, status }))
+
+  if (failedPlugins.size > 0 || error) {
+    const allErrors = [error, ...Array.from(failedPlugins, (it) => it.error)].filter(Boolean) as Error[]
+
+    for (const err of allErrors) {
+      await hooks.emit('kubb:error', { error: err })
+    }
+
+    await hooks.emit('kubb:generation:end', { config, files, sources: kubb.sources })
+    await hooks.emit('kubb:generation:summary', {
+      config,
+      failedPlugins,
+      filesCreated: files.length,
+      status: 'failed',
+      hrStart,
+      pluginTimings: logLevel >= logLevelMap.verbose ? pluginTimings : undefined,
+    })
+
+    await reportTelemetry('failed')
+    process.exit(1)
+  }
+
+  await hooks.emit('kubb:success', { message: 'Generation succeeded', info: inputPath })
+  await hooks.emit('kubb:generation:end', { config, files, sources: kubb.sources })
+
+  const outputPath = path.resolve(config.root, config.output.path)
+
+  const toolPasses = [
+    config.output.format && {
+      toolValue: config.output.format,
+      detect: detectFormatter,
+      toolMap: formatters,
+      toolLabel: 'formatter',
+      successPrefix: 'Formatting',
+      noToolMessage: 'No formatter found (oxfmt, biome, or prettier). Skipping formatting.',
+      onStart: () => hooks.emit('kubb:format:start'),
+      onEnd: () => hooks.emit('kubb:format:end'),
+    },
+    config.output.lint && {
+      toolValue: config.output.lint,
+      detect: detectLinter,
+      toolMap: linters,
+      toolLabel: 'linter',
+      successPrefix: 'Linting',
+      noToolMessage: 'No linter found (oxlint, biome, or eslint). Skipping linting.',
+      onStart: () => hooks.emit('kubb:lint:start'),
+      onEnd: () => hooks.emit('kubb:lint:end'),
+    },
+  ].filter(Boolean) as Omit<RunToolPassOptions, 'configName' | 'outputPath' | 'logLevel' | 'hooks'>[]
+
+  for (const pass of toolPasses) {
+    await runToolPass({ ...pass, configName: config.name, outputPath, logLevel, hooks })
+  }
+
+  if (config.hooks) {
+    await hooks.emit('kubb:hooks:start')
+    await executeHooks({ configHooks: config.hooks, hooks, makeSink })
+    await hooks.emit('kubb:hooks:end')
+  }
+
+  await hooks.emit('kubb:generation:summary', { config, failedPlugins, filesCreated: files.length, status: 'success', hrStart, pluginTimings })
+
+  await reportTelemetry('success')
+}
+
+type GenerateCommandOptions = {
+  input?: string
+  configPath?: string
+  logLevel: string
+  watch: boolean
+}
+
+async function checkForUpdate(hooks: AsyncEventEmitter<KubbHooks>): Promise<void> {
+  await executeIfOnline(async () => {
+    try {
+      const res = await fetch(KUBB_NPM_PACKAGE_URL)
+      const data = (await res.json()) as { version: string }
+      if (data.version && version < data.version) {
+        await hooks.emit('kubb:version:new', { currentVersion: version, latestVersion: data.version })
+      }
+    } catch {
+      // Ignore network errors
+    }
+  })
+}
+
+/**
+ * Runs the full Kubb generation lifecycle for the given CLI options.
+ * Sets up the logger, checks for a newer version, loads configs, and calls `generate` for each config entry.
+ */
+export async function run({ input, configPath, logLevel: logLevelKey, watch }: GenerateCommandOptions): Promise<void> {
+  const logLevel = logLevelMap[logLevelKey as keyof typeof logLevelMap] ?? logLevelMap.info
+  const hooks = new AsyncEventEmitterClass<KubbHooks>()
+
+  const makeSink = await setupLogger(hooks, { logLevel })
+
+  await checkForUpdate(hooks)
+
+  try {
+    const { configs, configPath: resolvedConfigPath } = await getConfigs({ configPath, input })
+    const relativeConfigPath = path.relative(process.cwd(), resolvedConfigPath)
+
+    await hooks.emit('kubb:config:start')
+    await hooks.emit('kubb:info', { message: 'Config loaded', info: relativeConfigPath })
+    await hooks.emit('kubb:success', { message: 'Config loaded successfully', info: relativeConfigPath })
+    await hooks.emit('kubb:config:end', { configs })
+    await hooks.emit('kubb:lifecycle:start', { version })
+
+    for (const config of configs) {
+      if (isInputPath(config) && watch) {
+        await startWatcher(
+          [input || config.input.path],
+          async (paths) => {
+            hooks.removeAll()
+            await generate({ input, config, logLevel, hooks, makeSink })
+            clack.log.step(styleText('yellow', `Watching for changes in ${paths.join(' and ')}`))
+          },
+          { info: (msg) => clack.log.info(msg), error: (msg) => clack.log.error(msg) },
+        )
+      } else {
+        await generate({ input, config, logLevel, hooks, makeSink })
+      }
+    }
+
+    await hooks.emit('kubb:lifecycle:end')
+  } catch (error) {
+    await hooks.emit('kubb:error', { error: toError(error) })
+    process.exit(1)
+  }
+}

package/src/runners/generate/utils.ts

@@ -0,0 +1,209 @@
+import { createHash } from 'node:crypto'
+import { styleText } from 'node:util'
+import type { AsyncEventEmitter } from '@internals/utils'
+import { toError, tokenize } from '@internals/utils'
+import type { CLIOptions, Config, KubbHooks, PossibleConfig } from '@kubb/core'
+import { cosmiconfig } from 'cosmiconfig'
+import { createJiti } from 'jiti'
+import { NonZeroExitError, x } from 'tinyexec'
+import type { HookSinkOptions } from '../../loggers/utils.ts'
+import { WATCHER_IGNORED_PATHS } from '../../constants.ts'
+
+type CosmiconfigResult = {
+  filepath: string
+  isEmpty?: boolean
+  config: PossibleConfig<CLIOptions>
+}
+
+const jiti = createJiti(import.meta.url, {
+  jsx: { runtime: 'automatic', importSource: '@kubb/renderer-jsx' },
+  moduleCache: false,
+})
+
+const tsLoader = (configFile: string) => jiti.import(configFile, { default: true })
+
+const MODULE_NAME = 'kubb'
+
+const BASE_SEARCH_PLACES = [
+  'package.json',
+  `.${MODULE_NAME}rc`,
+  `.${MODULE_NAME}rc.json`,
+  `.${MODULE_NAME}rc.yaml`,
+  `.${MODULE_NAME}rc.yml`,
+  `.${MODULE_NAME}rc.ts`,
+  `.${MODULE_NAME}rc.mts`,
+  `.${MODULE_NAME}rc.cts`,
+  `.${MODULE_NAME}rc.js`,
+  `.${MODULE_NAME}rc.mjs`,
+  `.${MODULE_NAME}rc.cjs`,
+  `${MODULE_NAME}.config.ts`,
+  `${MODULE_NAME}.config.mts`,
+  `${MODULE_NAME}.config.cts`,
+  `${MODULE_NAME}.config.js`,
+  `${MODULE_NAME}.config.mjs`,
+  `${MODULE_NAME}.config.cjs`,
+]
+
+const SEARCH_PLACES = ['', '.config/', 'configs/'].flatMap((prefix) => BASE_SEARCH_PLACES.map((p) => `${prefix}${p}`))
+
+async function getCosmiConfig(configFile?: string): Promise<CosmiconfigResult> {
+  const explorer = cosmiconfig(MODULE_NAME, {
+    cache: false,
+    searchPlaces: SEARCH_PLACES,
+    loaders: { '.ts': tsLoader, '.mts': tsLoader, '.cts': tsLoader },
+  })
+
+  let result: CosmiconfigResult
+  try {
+    result = (configFile ? await explorer.load(configFile) : await explorer.search()) as CosmiconfigResult
+  } catch (error) {
+    throw new Error('Config failed loading', { cause: error })
+  }
+
+  if (!result?.config || result.isEmpty) {
+    throw new Error('Config not defined, create a kubb.config.js or pass through your config with the option --config')
+  }
+
+  return result
+}
+
+type GetConfigsOptions = {
+  /**
+   * Explicit path to the Kubb config file. When omitted, cosmiconfig searches from the current directory.
+   */
+  configPath?: string
+  /**
+   * Optional OpenAPI input path that overrides `config.input.path` for this run.
+   */
+  input?: string
+}
+
+type GetConfigsResult = {
+  /**
+   * Absolute path to the resolved config file.
+   */
+  configPath: string
+  /**
+   * Resolved and normalized array of Kubb configs, each guaranteed to have a `plugins` array.
+   */
+  configs: Array<Config>
+}
+
+/**
+ * Discovers the Kubb config via cosmiconfig and resolves it into a normalized array of configs.
+ * Every config in the result is guaranteed to have a `plugins` array.
+ */
+export async function getConfigs({ configPath, input }: GetConfigsOptions): Promise<GetConfigsResult> {
+  const result = await getCosmiConfig(configPath)
+  const resolved = await (typeof result.config === 'function' ? result.config({ input } as CLIOptions) : result.config)
+  const userConfigs = Array.isArray(resolved) ? resolved : [resolved]
+
+  return {
+    configPath: result.filepath,
+    configs: userConfigs.map((item) => ({ ...item, plugins: item.plugins ?? [] }) as Config),
+  }
+}
+
+type ExecuteHooksOptions = {
+  configHooks: NonNullable<Config['hooks']>
+  hooks: AsyncEventEmitter<KubbHooks>
+  makeSink?: (commandWithArgs: string) => HookSinkOptions | undefined
+}
+
+/**
+ * Runs the `done` hooks defined in a Kubb config in sequence.
+ */
+export async function executeHooks({ configHooks, hooks, makeSink }: ExecuteHooksOptions): Promise<void> {
+  const commands = Array.isArray(configHooks.done) ? configHooks.done : [configHooks.done].filter(Boolean)
+
+  for (const command of commands) {
+    const [cmd, ...args] = tokenize(command)
+    if (!cmd) continue
+
+    const hookId = createHash('sha256').update(command).digest('hex')
+    const commandWithArgs = [cmd, ...args].join(' ')
+
+    await hooks.emit('kubb:hook:start', { id: hookId, command: cmd, args })
+
+    const { stream = false, onLine, onStdout, onStderr } = makeSink?.(commandWithArgs) ?? {}
+    await runHook({ id: hookId, command: cmd, args, commandWithArgs, context: hooks, stream, sink: { onLine, onStdout, onStderr } })
+  }
+}
+
+type RunHookOptions = {
+  id: string
+  command: string
+  args?: readonly string[]
+  commandWithArgs: string
+  context: AsyncEventEmitter<KubbHooks>
+  stream?: boolean
+  sink?: HookSinkOptions
+}
+
+async function runHook({ id, command, args, commandWithArgs, context, stream = false, sink }: RunHookOptions): Promise<void> {
+  const emitEnd = (success: boolean, error: Error | null) => context.emit('kubb:hook:end', { command, args, id, success, error })
+
+  try {
+    const proc = x(command, [...(args ?? [])], {
+      nodeOptions: { detached: process.platform !== 'win32' },
+      throwOnError: true,
+    })
+
+    if (stream && sink?.onLine) {
+      for await (const line of proc) {
+        sink.onLine(line)
+      }
+    }
+
+    const result = await proc
+    await context.emit('kubb:debug', { date: new Date(), logs: [result.stdout.trimEnd()] })
+    await context.emit('kubb:success', { message: `${styleText('dim', commandWithArgs)} successfully executed` })
+    await emitEnd(true, null)
+  } catch (err) {
+    if (!(err instanceof NonZeroExitError)) {
+      const error = toError(err)
+      await emitEnd(false, error)
+      await context.emit('kubb:error', { error })
+      return
+    }
+
+    const stderr = err.output?.stderr ?? ''
+    const stdout = err.output?.stdout ?? ''
+
+    await context.emit('kubb:debug', { date: new Date(), logs: [stdout, stderr].filter(Boolean) })
+
+    if (stderr) sink?.onStderr?.(stderr)
+    if (stdout) sink?.onStdout?.(stdout)
+
+    const error = new Error(`Hook execute failed: ${commandWithArgs}`)
+    await emitEnd(false, error)
+    await context.emit('kubb:error', { error })
+  }
+}
+
+type WatcherLog = {
+  info: (message: string) => void
+  error: (message: string) => void
+}
+
+/**
+ * Starts a file watcher on the given paths and calls `cb` on any change.
+ * Ignores `.git` and `node_modules` directories.
+ */
+export async function startWatcher(
+  path: string[],
+  cb: (path: string[]) => Promise<void>,
+  log: WatcherLog = { info: console.log, error: console.log },
+): Promise<void> {
+  const { watch } = await import('chokidar')
+  const watcher = watch(path, { ignorePermissionErrors: true, ignored: WATCHER_IGNORED_PATHS })
+
+  watcher.on('all', async (type, file) => {
+    log.info(styleText('yellow', styleText('bold', `Change detected: ${type} ${file}`)))
+    try {
+      await cb(path)
+    } catch (_e) {
+      log.error(styleText('red', 'Watcher failed'))
+    }
+  })
+}