@kubb/cli 5.0.0-beta.7 → 5.0.0-beta.70

package/src/runners/init/utils.ts

@@ -1,33 +0,0 @@
-import fs from 'node:fs'
-import path from 'node:path'
-import process from 'node:process'
-import type { PackageManagerInfo, PackageManagerName } from '@internals/utils'
-import { spawnAsync } from '@internals/utils'
-
-/**
- * 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, string[]> = {
-    npm: ['init', '-y'],
-    pnpm: ['init'],
-    yarn: ['init', '-y'],
-    bun: ['init', '-y'],
-  }
-
-  await spawnAsync(packageManager.name, commands[packageManager.name], { cwd })
-}
-
-/**
- * Installs the given packages at `cwd` using the detected package manager.
- */
-export async function installPackages(packages: string[], packageManager: PackageManagerInfo, cwd: string = process.cwd()): Promise<void> {
-  await spawnAsync(packageManager.name, [...packageManager.installCommand, ...packages], { cwd })
-}

package/src/runners/mcp/run.ts

@@ -1,55 +0,0 @@
-import process from 'node:process'
-import { styleText } from 'node:util'
-import { getErrorMessage } from '@internals/utils'
-import type * as McpModule from '@kubb/mcp'
-import { buildTelemetryEvent, sendTelemetry } from '../../telemetry.ts'
-
-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
-}
-
-/**
- * Starts the Kubb MCP server using `@kubb/mcp`.
- * Exits the process with code 1 if `@kubb/mcp` is not installed.
- */
-export async function run({ version, port, host }: McpOptions): Promise<void> {
-  let mod: typeof McpModule
-  try {
-    mod = (await import('@kubb/mcp')) as typeof McpModule
-  } catch (_e) {
-    console.error(styleText('red', 'The @kubb/mcp package is not installed.'))
-    console.error('')
-    console.error('Install it with:')
-    console.error(styleText('cyan', '  npm install @kubb/mcp'))
-    console.error(styleText('cyan', '  # or'))
-    console.error(styleText('cyan', '  pnpm install @kubb/mcp'))
-    console.error('')
-    process.exit(1)
-  }
-
-  const { run: startMcpServer } = mod
-  const hrStart = process.hrtime()
-  const report = (status: 'success' | 'failed') => sendTelemetry(buildTelemetryEvent({ 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/run.ts

@@ -1,63 +0,0 @@
-import process from 'node:process'
-import { styleText } from 'node:util'
-import { getErrorMessage } from '@internals/utils'
-import { buildTelemetryEvent, sendTelemetry } 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>
-}
-
-/**
- * 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') => sendTelemetry(buildTelemetryEvent({ command: 'validate', kubbVersion: version, hrStart, status }))
-  try {
-    const { adapterOas } = await dependencies.loadValidateModule()
-    const adapter = adapterOas()
-    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 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('')
-      console.error('Install it with:')
-      console.error(styleText('cyan', '  npm install @kubb/adapter-oas'))
-      console.error(styleText('cyan', '  # or'))
-      console.error(styleText('cyan', '  pnpm install @kubb/adapter-oas'))
-      console.error('')
-    }
-    console.error('❌ Validation failed')
-    console.error(getErrorMessage(error))
-    process.exit(1)
-  }
-}

package/src/telemetry.ts

@@ -1,280 +0,0 @@
-import { randomBytes } from 'node:crypto'
-import os from 'node:os'
-import process from 'node:process'
-import { executeIfOnline, isCIEnvironment } from '@internals/utils'
-import { OTLP_ENDPOINT } from './constants.ts'
-
-// OpenTelemetry OTLP JSON types
-// https://github.com/open-telemetry/opentelemetry-proto/blob/main/opentelemetry/proto/trace/v1/trace.proto
-// https://github.com/open-telemetry/opentelemetry-proto/blob/main/opentelemetry/proto/common/v1/common.proto
-
-type OtlpStringValue = { stringValue: string }
-type OtlpBoolValue = { boolValue: boolean }
-type OtlpIntValue = { intValue: number }
-type OtlpDoubleValue = { doubleValue: number }
-type OtlpBytesValue = { bytesValue: string }
-type OtlpArrayValue = { arrayValue: { values: OtlpAnyValue[] } }
-type OtlpKvListValue = { kvlistValue: { values: OtlpKeyValue[] } }
-
-type OtlpAnyValue = OtlpStringValue | OtlpBoolValue | OtlpIntValue | OtlpDoubleValue | OtlpBytesValue | OtlpArrayValue | OtlpKvListValue
-
-type OtlpKeyValue = {
-  key: string
-  value: OtlpAnyValue
-}
-
-type OtlpResource = {
-  attributes: OtlpKeyValue[]
-  droppedAttributesCount?: number
-}
-
-type OtlpInstrumentationScope = {
-  name: string
-  version?: string
-  attributes?: OtlpKeyValue[]
-  droppedAttributesCount?: number
-}
-
-/** https://github.com/open-telemetry/opentelemetry-proto/blob/main/opentelemetry/proto/trace/v1/trace.proto#L103 */
-type OtlpSpanKind = 0 | 1 | 2 | 3 | 4 | 5
-
-/** 0 = STATUS_CODE_UNSET, 1 = STATUS_CODE_OK, 2 = STATUS_CODE_ERROR */
-type OtlpStatusCode = 0 | 1 | 2
-
-type OtlpStatus = {
-  code: OtlpStatusCode
-  message?: string
-}
-
-type OtlpSpan = {
-  traceId: string
-  spanId: string
-  traceState?: string
-  parentSpanId?: string
-  name: string
-  kind: OtlpSpanKind
-  startTimeUnixNano: string
-  endTimeUnixNano: string
-  attributes?: OtlpKeyValue[]
-  droppedAttributesCount?: number
-  events?: OtlpSpanEvent[]
-  droppedEventsCount?: number
-  links?: OtlpSpanLink[]
-  droppedLinksCount?: number
-  status?: OtlpStatus
-}
-
-type OtlpSpanEvent = {
-  timeUnixNano: string
-  name: string
-  attributes?: OtlpKeyValue[]
-  droppedAttributesCount?: number
-}
-
-type OtlpSpanLink = {
-  traceId: string
-  spanId: string
-  traceState?: string
-  attributes?: OtlpKeyValue[]
-  droppedAttributesCount?: number
-}
-
-type OtlpScopeSpans = {
-  scope: OtlpInstrumentationScope
-  spans: OtlpSpan[]
-  schemaUrl?: string
-}
-
-type OtlpResourceSpans = {
-  resource: OtlpResource
-  scopeSpans: OtlpScopeSpans[]
-  schemaUrl?: string
-}
-
-/** Root payload sent to POST /v1/traces */
-type OtlpExportTraceServiceRequest = {
-  resourceSpans: OtlpResourceSpans[]
-}
-
-/**
- * Anonymous plugin name and options snapshot sent with each telemetry event.
- */
-export type TelemetryPlugin = {
-  /**
-   * Plugin name as registered in the Kubb config, e.g. `'@kubb/plugin-ts'`.
-   */
-  name: string
-  /**
-   * anonymized plugin options snapshot — values are included but cannot be traced back to the user.
-   */
-  options: Record<string, unknown>
-}
-
-type TelemetryEvent = {
-  command: string
-  kubbVersion: string
-  nodeVersion: string
-  platform: string
-  ci: boolean
-  plugins: TelemetryPlugin[]
-  duration: number
-  filesCreated: number
-  status: 'success' | 'failed'
-}
-
-/**
- * Returns `true` when the current process runs inside a CI environment.
- */
-export function isCi(): boolean {
-  return isCIEnvironment()
-}
-
-/**
- * Returns `true` when telemetry is disabled via `DO_NOT_TRACK` or `KUBB_DISABLE_TELEMETRY`.
- */
-export function isTelemetryDisabled(): boolean {
-  return (
-    process.env['DO_NOT_TRACK'] === '1' ||
-    process.env['DO_NOT_TRACK'] === 'true' ||
-    process.env['KUBB_DISABLE_TELEMETRY'] === '1' ||
-    process.env['KUBB_DISABLE_TELEMETRY'] === 'true'
-  )
-}
-
-/**
- * Convert a TelemetryEvent into an OTLP-compatible JSON trace payload.
- * See https://opentelemetry.io/docs/languages/sdk-configuration/otlp-exporter/
- */
-export function buildOtlpPayload(event: TelemetryEvent): OtlpExportTraceServiceRequest {
-  const traceId = randomBytes(16).toString('hex')
-  const spanId = randomBytes(8).toString('hex')
-  const endTimeNs = BigInt(Date.now()) * 1_000_000n
-  const startTimeNs = endTimeNs - BigInt(event.duration) * 1_000_000n
-
-  const attributes: OtlpKeyValue[] = [
-    { key: 'kubb.command', value: { stringValue: event.command } },
-    { key: 'kubb.version', value: { stringValue: event.kubbVersion } },
-    { key: 'kubb.node_version', value: { stringValue: event.nodeVersion } },
-    { key: 'kubb.platform', value: { stringValue: event.platform } },
-    { key: 'kubb.ci', value: { boolValue: event.ci } },
-    { key: 'kubb.files_created', value: { intValue: event.filesCreated } },
-    { key: 'kubb.status', value: { stringValue: event.status } },
-    {
-      key: 'kubb.plugins',
-      value: {
-        arrayValue: {
-          values: event.plugins.map(
-            (p): OtlpKvListValue => ({
-              kvlistValue: {
-                values: [
-                  { key: 'name', value: { stringValue: p.name } },
-                  {
-                    key: 'options',
-                    value: {
-                      stringValue: JSON.stringify({
-                        ...p.options,
-                        usedEnumNames: undefined,
-                      }),
-                    },
-                  },
-                ],
-              },
-            }),
-          ),
-        },
-      },
-    },
-  ]
-
-  return {
-    resourceSpans: [
-      {
-        resource: {
-          attributes: [
-            { key: 'service.name', value: { stringValue: 'kubb-cli' } },
-            {
-              key: 'service.version',
-              value: { stringValue: event.kubbVersion },
-            },
-            { key: 'telemetry.sdk.language', value: { stringValue: 'nodejs' } },
-          ],
-        },
-        scopeSpans: [
-          {
-            scope: { name: 'kubb-cli', version: event.kubbVersion },
-            spans: [
-              {
-                traceId,
-                spanId,
-                name: event.command,
-                kind: 1 satisfies OtlpSpanKind,
-                startTimeUnixNano: String(startTimeNs),
-                endTimeUnixNano: String(endTimeNs),
-                attributes,
-                status: {
-                  code: (event.status === 'success' ? 1 : 2) satisfies OtlpStatusCode,
-                },
-              },
-            ],
-          },
-        ],
-      },
-    ],
-  }
-}
-
-/**
- * Send an anonymous telemetry event to the Kubb OTLP endpoint.
- * Respects DO_NOT_TRACK and KUBB_DISABLE_TELEMETRY environment variables.
- * Fails silently to never interrupt the generation process.
- */
-export async function sendTelemetry(event: TelemetryEvent): Promise<void> {
-  if (isTelemetryDisabled()) {
-    return
-  }
-
-  await executeIfOnline(async () => {
-    try {
-      await fetch(`${OTLP_ENDPOINT}/v1/traces`, {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-          'Kubb-Telemetry-Version': '1',
-          'Kubb-Telemetry-Source': 'kubb-cli',
-        },
-        body: JSON.stringify(buildOtlpPayload(event)),
-        signal: AbortSignal.timeout(5_000),
-      })
-    } catch (_e) {
-      // Fail silently – telemetry must never break the CLI
-    }
-  })
-}
-
-/**
- * Build an anonymous telemetry payload from a completed generation run.
- * No file paths, OpenAPI specs, or secrets are included.
- */
-export function buildTelemetryEvent(options: {
-  command: 'generate' | 'mcp' | 'validate' | 'agent'
-  kubbVersion: string
-  plugins?: TelemetryPlugin[]
-  hrStart: [number, number]
-  filesCreated?: number
-  status: 'success' | 'failed'
-}): TelemetryEvent {
-  const [seconds, nanoseconds] = process.hrtime(options.hrStart)
-  const duration = Math.round(seconds * 1000 + nanoseconds / 1e6)
-
-  return {
-    command: options.command,
-    kubbVersion: options.kubbVersion,
-    nodeVersion: process.versions.node.split('.')[0] as string,
-    platform: os.platform(),
-    ci: isCi(),
-    plugins: options.plugins ?? [],
-    duration,
-    filesCreated: options.filesCreated ?? 0,
-    status: options.status,
-  }
-}