@kubb/cli 5.0.6 → 5.2.0

package/dist/run-DRBqVXX0.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-DRBqVXX0.cjs","names":["availablePlugins","join","existsSync","readFileSync","process","fs","path","x","process","styleText","clack","createSpinner","initDefaults","availablePlugins","KUBB_PACKAGE_NAME","KUBB_CONFIG_FILENAME","path","fs"],"sources":["../../../internals/shared/src/init.ts","../src/tools.ts","../src/runners/init/utils.ts","../src/runners/init/run.ts"],"sourcesContent":["import { availablePlugins, KUBB_PACKAGE_NAME } from './constants.ts'\nimport type { PluginOption } from './types.ts'\n\n/**\n * Resolves a comma-separated plugin flag (e.g. `--plugins plugin-ts,plugin-zod`) into the\n * matching known plugin options. Unrecognized names are dropped, and a missing flag yields\n * an empty list.\n */\nexport function resolvePlugins(pluginsFlag: string | undefined): Array<PluginOption> {\n  if (!pluginsFlag) {\n    return []\n  }\n  const requested = pluginsFlag\n    .split(',')\n    .map((value) => value.trim())\n    .filter(Boolean)\n  return availablePlugins.filter((plugin) => requested.includes(plugin.value))\n}\n\nexport function generateConfigFile({\n  selectedPlugins,\n  inputPath,\n  outputPath,\n}: {\n  selectedPlugins: Array<PluginOption>\n  inputPath: string\n  outputPath: string\n}): string {\n  const imports = selectedPlugins.map((plugin) => `import { ${plugin.importName} } from '${plugin.packageName}'`).join('\\n')\n\n  const pluginConfigs = selectedPlugins.map((plugin) => `    ${plugin.importName}(),`).join('\\n')\n\n  return `import { defineConfig } from 'kubb/config'\n${imports}\n\nexport default defineConfig({\n  input: '${inputPath}',\n  output: {\n    path: '${outputPath}',\n    clean: true,\n  },\n  plugins: [\n${pluginConfigs}\n  ],\n})\n`\n}\n\n/**\n * Turns package names into install specifiers for the wizard.\n *\n * `kubb` is pinned to the exact version of the running CLI, since both ship from the same release\n * and resolving `kubb@beta` separately can land on a different version than the CLI doing the\n * scaffolding. Plugins release from their own repo on their own cadence, so they follow the\n * release channel of the CLI through its dist-tag.\n */\nexport function resolveInstallVersions({ packages, version }: { packages: Array<string>; version: string }): Array<string> {\n  const prerelease = version.match(/-([a-z]+)/)?.[1]\n  const tag = prerelease ?? 'latest'\n\n  return packages.map((name) => (name === KUBB_PACKAGE_NAME ? `${name}@${version}` : `${name}@${tag}`))\n}\n","import { existsSync, readFileSync } from 'node:fs'\nimport { join } from 'node:path'\nimport { formatters, linters } from '@internals/utils'\nimport type { Config } from '@kubb/core'\n\n/**\n * The configurable formatter names, mirrored from `Config['output'].format`. Excludes `'auto'`\n * (detection, not a tool) and `false` (skip). The `formatters`/`linters` tables below are pinned to\n * these so adding a tool to the config union without a descriptor fails to compile.\n */\ntype FormatterName = Exclude<NonNullable<Config['output']['format']>, 'auto' | false>\ntype LinterName = Exclude<NonNullable<Config['output']['lint']>, 'auto' | false>\n\n// Pinned to core's union here rather than in `@internals/utils`, which must not import `@kubb/core`:\n// adding a tool to the config union without a descriptor stays a compile error.\nformatters satisfies Record<FormatterName, unknown>\nlinters satisfies Record<LinterName, unknown>\n\nexport { detectTool, formatters, linters } from '@internals/utils'\n\nexport type PackageManagerName = 'npm' | 'pnpm' | 'yarn' | 'bun'\n\n/**\n * Metadata describing a package manager's lock file and install command.\n */\nexport interface PackageManagerInfo {\n  /**\n   * Identifier used in CLI commands, e.g. `pnpm`, `yarn`.\n   */\n  name: PackageManagerName\n  /**\n   * Lock file name that uniquely identifies this package manager in a project root.\n   */\n  lockFile: string\n  /**\n   * Subcommands passed to the package manager binary to install a dev dependency.\n   */\n  installCommand: ReadonlyArray<string>\n}\n\n/**\n * Metadata for each supported package manager, keyed by its short name.\n *\n * @example\n * ```ts\n * packageManagers.pnpm.installCommand // ['add', '-D']\n * packageManagers.npm.lockFile        // 'package-lock.json'\n * ```\n */\nconst packageManagers: Record<PackageManagerName, PackageManagerInfo> = {\n  pnpm: {\n    name: 'pnpm',\n    lockFile: 'pnpm-lock.yaml',\n    installCommand: ['add', '-D'],\n  },\n  yarn: {\n    name: 'yarn',\n    lockFile: 'yarn.lock',\n    installCommand: ['add', '-D'],\n  },\n  bun: {\n    name: 'bun',\n    lockFile: 'bun.lockb',\n    installCommand: ['add', '-d'],\n  },\n  npm: {\n    name: 'npm',\n    lockFile: 'package-lock.json',\n    installCommand: ['install', '--save-dev'],\n  },\n}\n\n/**\n * Minimal shape of `package.json` fields read during detection.\n */\ntype PackageJson = {\n  /**\n   * The `packageManager` field from `package.json` (e.g. `\"pnpm@9.0.0\"`).\n   */\n  packageManager?: string\n}\n\n/**\n * Detects the active package manager for the given directory.\n * Resolution order: `packageManager` field in `package.json`, then presence of a lock file.\n * Falls back to `npm` when no signal is found.\n *\n * @example\n * ```ts\n * detectPackageManager('/my/project') // { name: 'pnpm', lockFile: 'pnpm-lock.yaml', ... }\n * detectPackageManager()              // falls back to npm when no lock file is found\n * ```\n */\nexport function detectPackageManager(cwd: string = process.cwd()): PackageManagerInfo {\n  const packageJsonPath = join(cwd, 'package.json')\n  if (existsSync(packageJsonPath)) {\n    try {\n      const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8')) as PackageJson\n      const pmField = packageJson.packageManager\n      if (typeof pmField === 'string') {\n        const name = pmField.split('@')[0]\n        if (name && name in packageManagers) {\n          return packageManagers[name as PackageManagerName]\n        }\n      }\n    } catch {\n      // Continue to lock file detection\n    }\n  }\n\n  for (const pm of Object.values(packageManagers)) {\n    if (existsSync(join(cwd, pm.lockFile))) {\n      return pm\n    }\n  }\n\n  return packageManagers.npm\n}\n","import fs from 'node:fs'\nimport path from 'node:path'\nimport process from 'node:process'\nimport { x } from 'tinyexec'\nimport type { PackageManagerInfo, PackageManagerName } from '../../tools.ts'\n\n/**\n * Returns `true` when a `package.json` exists at `cwd`.\n */\nexport function hasPackageJson(cwd: string = process.cwd()): boolean {\n  return fs.existsSync(path.join(cwd, 'package.json'))\n}\n\n/**\n * Initializes a new `package.json` at `cwd` using the detected package manager.\n */\nexport async function initPackageJson(cwd: string, packageManager: PackageManagerInfo): Promise<void> {\n  const commands: Record<PackageManagerName, Array<string>> = {\n    npm: ['init', '-y'],\n    pnpm: ['init'],\n    yarn: ['init', '-y'],\n    bun: ['init', '-y'],\n  }\n\n  await x(packageManager.name, commands[packageManager.name], {\n    nodeOptions: { cwd, stdio: 'inherit' },\n    throwOnError: true,\n  })\n}\n\n/**\n * Installs the given packages at `cwd` using the detected package manager.\n */\nexport async function installPackages(packages: Array<string>, packageManager: PackageManagerInfo, cwd: string = process.cwd()): Promise<void> {\n  await x(packageManager.name, [...packageManager.installCommand, ...packages], {\n    nodeOptions: { cwd, stdio: 'inherit' },\n    throwOnError: true,\n  })\n}\n","import fs from 'node:fs'\nimport path from 'node:path'\nimport process from 'node:process'\nimport { styleText } from 'node:util'\nimport * as clack from '@clack/prompts'\nimport type { DryRunExtension } from '@gunshi/plugin-dryrun'\nimport {\n  availablePlugins,\n  generateConfigFile,\n  initDefaults,\n  KUBB_CONFIG_FILENAME,\n  KUBB_PACKAGE_NAME,\n  type PluginOption,\n  resolveInstallVersions,\n  resolvePlugins,\n} from '@internals/shared'\nimport { createSpinner, logError, logInfo, logIntro, logOutro, logWarn } from '../../loggers/output.ts'\nimport { hasPackageJson, initPackageJson, installPackages } from './utils.ts'\nimport { detectPackageManager } from '../../tools.ts'\n\nfunction cancelAndExit(message = 'Operation canceled.'): never {\n  clack.cancel(message)\n  process.exit(0)\n}\n\ntype InitOptions = {\n  /**\n   * When `true`, skips all interactive prompts and uses default values.\n   */\n  yes: boolean\n  /**\n   * Current `@kubb/cli` version string, shown in the closing outro.\n   */\n  version: string\n  /**\n   * Input path flag value from `--input`. When provided, skips the input prompt.\n   */\n  input?: string\n  /**\n   * Output directory flag value from `--output`. When provided, skips the output prompt.\n   */\n  output?: string\n  /**\n   * Comma-separated plugin list from `--plugins`, e.g. `'plugin-ts,plugin-zod'`. When provided, skips the plugin selection prompt.\n   */\n  plugins?: string\n  /**\n   * Dry-run extension from `@gunshi/plugin-dryrun`. When enabled, package installation and the\n   * config file write are skipped.\n   */\n  dryRun: DryRunExtension\n}\n\n/**\n * Runs the interactive Kubb scaffolding wizard.\n * Detects the package manager, prompts for input/output paths and plugins, installs packages, and writes `kubb.config.ts`.\n * Pass `yes: true` to skip all prompts and use defaults.\n */\nexport async function run({ yes, version, input: inputFlag, output: outputFlag, plugins: pluginsFlag, dryRun }: InitOptions): Promise<void> {\n  const cwd = process.cwd()\n\n  logIntro({ title: styleText('bgCyan', styleText('black', ' Kubb Init ')) })\n\n  /**\n   * Returns `flag` when provided, the `defaultValue` when `yes` is set,\n   * or calls `prompt()` for interactive input. Exits on cancellation.\n   */\n  async function resolveOrPrompt<T>(flag: T | undefined, defaultValue: T, logLabel: string, prompt: () => Promise<T | symbol>): Promise<T> {\n    if (flag !== undefined) {\n      logInfo(`${logLabel}: ${styleText('cyan', String(flag))}`)\n      return flag\n    }\n    if (yes) {\n      logInfo(`${logLabel}: ${styleText('cyan', String(defaultValue))}`)\n      return defaultValue\n    }\n    const result = await prompt()\n    if (clack.isCancel(result)) cancelAndExit()\n    return result as T\n  }\n\n  try {\n    // Check/create package.json, detect package manager once after the block\n    if (!hasPackageJson(cwd)) {\n      if (!yes) {\n        const shouldInit = await clack.confirm({\n          message: 'No package.json found. Would you like to create one?',\n          initialValue: true,\n        })\n\n        if (clack.isCancel(shouldInit) || !shouldInit) {\n          cancelAndExit()\n        }\n      }\n\n      const packageManager = detectPackageManager(cwd)\n      const spinner = createSpinner()\n      spinner.start(`Initializing package.json with ${packageManager.name}`)\n      await initPackageJson(cwd, packageManager)\n      spinner.stop(`Created package.json with ${packageManager.name}`)\n    }\n\n    const packageManager = detectPackageManager(cwd)\n    if (hasPackageJson(cwd)) {\n      logInfo(`Detected package manager: ${styleText('cyan', packageManager.name)}`)\n    }\n\n    // Prompt for OpenAPI spec path\n    const inputPath = await resolveOrPrompt(inputFlag, initDefaults.inputPath, 'Using input path', () =>\n      clack.text({\n        message: 'Where is your OpenAPI specification located?',\n        placeholder: initDefaults.inputPath,\n        defaultValue: initDefaults.inputPath,\n        validate: (value) => {\n          if (!value) return 'Input path is required'\n        },\n      }),\n    )\n\n    // Prompt for output directory\n    const outputPath = await resolveOrPrompt(outputFlag, initDefaults.outputPath, 'Using output path', () =>\n      clack.text({\n        message: 'Where should the generated files be output?',\n        placeholder: initDefaults.outputPath,\n        defaultValue: initDefaults.outputPath,\n        validate: (value) => {\n          if (!value) return 'Output path is required'\n        },\n      }),\n    )\n\n    // Plugin selection\n    const defaultPlugins = availablePlugins.filter((p) => (initDefaults.plugins as ReadonlyArray<string>).includes(p.value))\n    const pluginLabel = (plugins: Array<PluginOption>) => styleText('cyan', plugins.map((p) => p.label).join(', '))\n\n    const selectedPlugins: Array<PluginOption> = await (async () => {\n      if (pluginsFlag) {\n        const plugins = resolvePlugins(pluginsFlag)\n        if (plugins.length === 0) {\n          logWarn(`No valid plugins found in --plugins value; falling back to default: ${pluginLabel(defaultPlugins)}`)\n          return defaultPlugins\n        }\n        logInfo(`Using plugins: ${pluginLabel(plugins)}`)\n        return plugins\n      }\n      if (yes) {\n        logInfo(`Using plugins: ${pluginLabel(defaultPlugins)}`)\n        return defaultPlugins\n      }\n      const values = await clack.multiselect({\n        message: 'Select plugins to use:',\n        options: availablePlugins.map(({ value, label, hint }) => ({ value, label, hint })),\n        initialValues: [...initDefaults.plugins],\n        required: true,\n      })\n      if (clack.isCancel(values)) cancelAndExit()\n      return availablePlugins.filter((p) => (values as Array<string>).includes(p.value))\n    })()\n\n    // Install packages, matching the release of the running CLI\n    const packagesToInstall = resolveInstallVersions({ packages: [KUBB_PACKAGE_NAME, ...selectedPlugins.map((p) => p.packageName)], version })\n\n    const spinner = createSpinner()\n    spinner.start(`Installing ${packagesToInstall.length} packages with ${packageManager.name}`)\n\n    try {\n      await dryRun.run(() => installPackages(packagesToInstall, packageManager, cwd), {\n        message: `install ${packagesToInstall.length} packages with ${packageManager.name}`,\n      })\n      spinner.stop(`Installed ${packagesToInstall.length} packages`)\n    } catch (error) {\n      spinner.stop('Installation failed')\n      throw error\n    }\n\n    // Generate config file\n    const configSpinner = createSpinner()\n    configSpinner.start(`Creating ${KUBB_CONFIG_FILENAME}`)\n\n    const configContent = generateConfigFile({ selectedPlugins, inputPath, outputPath })\n    const configPath = path.join(cwd, KUBB_CONFIG_FILENAME)\n\n    if (fs.existsSync(configPath)) {\n      configSpinner.stop(`${KUBB_CONFIG_FILENAME} already exists`)\n\n      if (!yes) {\n        const shouldOverwrite = await clack.confirm({\n          message: `${KUBB_CONFIG_FILENAME} already exists. Overwrite?`,\n          initialValue: false,\n        })\n\n        if (clack.isCancel(shouldOverwrite) || !shouldOverwrite) {\n          cancelAndExit('Keeping existing configuration. Packages have been installed.')\n        }\n      }\n\n      configSpinner.start(`Overwriting ${KUBB_CONFIG_FILENAME}`)\n    }\n\n    await dryRun.run(() => fs.promises.writeFile(configPath, configContent, 'utf-8'), { message: `write ${KUBB_CONFIG_FILENAME}` })\n\n    configSpinner.stop(`Created ${KUBB_CONFIG_FILENAME}`)\n\n    logOutro(\n      styleText('green', '✓ All set!') +\n        '\\n\\n' +\n        styleText('dim', 'Next steps:') +\n        '\\n' +\n        styleText('cyan', `  1. Make sure your OpenAPI spec is at: ${inputPath}`) +\n        '\\n' +\n        styleText('cyan', '  2. Generate code with: npx kubb generate') +\n        '\\n' +\n        styleText('cyan', `  3. Find generated files in: ${outputPath}`) +\n        '\\n\\n' +\n        styleText('dim', `Using ${packageManager.name} • Kubb v${version}`),\n    )\n  } catch (error) {\n    logError(styleText('red', 'An error occurred during initialization'))\n    if (error instanceof Error) {\n      logError(error.message)\n    }\n    process.exit(1)\n  }\n}\n"],"mappings":"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"}

package/dist/{run-ChKPZlIB.js → run-DReizVV9.js}

@@ -1,6 +1,7 @@
 import "./rolldown-runtime-C0LytTxp.js";
-import { r as sendTelemetry, t as buildTelemetryEvent } from "./Telemetry-Fiymfxez.js";
-import { n as toError } from "./errors-CMvLO2NE.js";
+import { t as toError } from "./errors-C8yNfV7w.js";
+import { r as sendTelemetry, t as buildTelemetryEvent } from "./Telemetry-BCTY-Nzq.js";
+import { t as version } from "./package-CrOAfe1h.js";
 import { styleText } from "node:util";
 import process from "node:process";
 //#region src/runners/validate/run.ts
@@ -39,7 +40,17 @@ async function run({ input, version }) {
 		process.exit(1);
 	}
 }
+/**
+* Loaded on demand by `index.ts`, so `@kubb/adapter-oas` stays out of the process for every other
+* command.
+*/
+const runner = async ({ values }) => {
+	await run({
+		input: values.input,
+		version
+	});
+};
 //#endregion
-export { run };
+export { runner };
 
-//# sourceMappingURL=run-ChKPZlIB.js.map
+//# sourceMappingURL=run-DReizVV9.js.map

package/dist/run-DReizVV9.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-DReizVV9.js","names":[],"sources":["../src/runners/validate/run.ts"],"sourcesContent":["import process from 'node:process'\nimport { styleText } from 'node:util'\nimport { toError } from '@internals/utils'\nimport type { CommandRunner } from 'gunshi'\nimport { buildTelemetryEvent, sendTelemetry } from '../../Telemetry.ts'\nimport { version } from '../../../package.json'\nimport type { definition } from '../../commands/validate.ts'\n\ntype ValidateOptions = {\n  /**\n   * Path or URL to the OpenAPI/Swagger file to validate.\n   */\n  input: string\n  /**\n   * Current `@kubb/cli` version string, used for the telemetry payload.\n   */\n  version: string\n}\n\n/**\n * Validates an OpenAPI/Swagger file at `input` using `@kubb/adapter-oas`.\n * Exits the process with code 1 on validation failure or missing dependency.\n */\nexport async function run({ input, version }: ValidateOptions): Promise<void> {\n  const hrStart = process.hrtime()\n  const report = (status: 'success' | 'failed') => sendTelemetry(buildTelemetryEvent({ command: 'validate', kubbVersion: version, hrStart, status }))\n\n  try {\n    const { adapterOas } = await import('@kubb/adapter-oas')\n\n    const adapter = adapterOas()\n    if (!adapter.validate) {\n      throw new Error('The loaded adapter does not support validation.')\n    }\n\n    await adapter.validate(input, { throwOnError: true })\n    await report('success')\n\n    console.log('✅ Validation success')\n  } catch (error) {\n    await report('failed')\n    if (error instanceof Error && /@kubb\\/adapter-oas/.test(error.message)) {\n      console.error(styleText('red', 'The @kubb/adapter-oas package is not installed.'))\n      console.error('')\n      console.error('Install it with:')\n      console.error(styleText('cyan', '  npm install @kubb/adapter-oas'))\n      console.error(styleText('cyan', '  # or'))\n      console.error(styleText('cyan', '  pnpm install @kubb/adapter-oas'))\n      console.error('')\n    }\n    console.error('❌ Validation failed')\n    console.error(toError(error).message)\n\n    process.exit(1)\n  }\n}\n\n/**\n * Loaded on demand by `index.ts`, so `@kubb/adapter-oas` stays out of the process for every other\n * command.\n */\nexport const runner: CommandRunner<{ args: typeof definition.args; extensions: {} }> = async ({ values }) => {\n  await run({ input: values.input, version })\n}\n"],"mappings":";;;;;;;;;;;AAuBA,eAAsB,IAAI,EAAE,OAAO,WAA2C;CAC5E,MAAM,UAAU,QAAQ,OAAO;CAC/B,MAAM,UAAU,WAAiC,cAAc,oBAAoB;EAAE,SAAS;EAAY,aAAa;EAAS;EAAS;CAAO,CAAC,CAAC;CAElJ,IAAI;EACF,MAAM,EAAE,eAAe,MAAM,OAAO;EAEpC,MAAM,UAAU,WAAW;EAC3B,IAAI,CAAC,QAAQ,UACX,MAAM,IAAI,MAAM,iDAAiD;EAGnE,MAAM,QAAQ,SAAS,OAAO,EAAE,cAAc,KAAK,CAAC;EACpD,MAAM,OAAO,SAAS;EAEtB,QAAQ,IAAI,sBAAsB;CACpC,SAAS,OAAO;EACd,MAAM,OAAO,QAAQ;EACrB,IAAI,iBAAiB,SAAS,qBAAqB,KAAK,MAAM,OAAO,GAAG;GACtE,QAAQ,MAAM,UAAU,OAAO,iDAAiD,CAAC;GACjF,QAAQ,MAAM,EAAE;GAChB,QAAQ,MAAM,kBAAkB;GAChC,QAAQ,MAAM,UAAU,QAAQ,iCAAiC,CAAC;GAClE,QAAQ,MAAM,UAAU,QAAQ,QAAQ,CAAC;GACzC,QAAQ,MAAM,UAAU,QAAQ,kCAAkC,CAAC;GACnE,QAAQ,MAAM,EAAE;EAClB;EACA,QAAQ,MAAM,qBAAqB;EACnC,QAAQ,MAAM,QAAQ,KAAK,CAAC,CAAC,OAAO;EAEpC,QAAQ,KAAK,CAAC;CAChB;AACF;;;;;AAMA,MAAa,SAA0E,OAAO,EAAE,aAAa;CAC3G,MAAM,IAAI;EAAE,OAAO,OAAO;EAAO;CAAQ,CAAC;AAC5C"}

package/dist/run-DUY0lV8l.js

@@ -0,0 +1,499 @@
+import "./rolldown-runtime-C0LytTxp.js";
+import { t as toError } from "./errors-C8yNfV7w.js";
+import { c as runtime, r as sendTelemetry, t as buildTelemetryEvent } from "./Telemetry-BCTY-Nzq.js";
+import { s as setupReporters, t as getConfigs } from "./utils-CzoNURwq.js";
+import { n as isCIEnvironment, t as canUseTTY } from "./env-DqPKEL59.js";
+import { t as version } from "./package-CrOAfe1h.js";
+import { a as logIntro, n as logBlock, o as logOutro, t as createSpinner } from "./output-LZvrgF3z.js";
+import { t as KUBB_CONFIG_FILENAME } from "./constants-DHRspBTo.js";
+import { styleText } from "node:util";
+import { homedir, hostname } from "node:os";
+import process from "node:process";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { cliReporter, logLevel } from "@kubb/core";
+import * as prompts from "@clack/prompts";
+import { x } from "tinyexec";
+import { PairingCanceledError, createFileStorage, defaultStudioUrl, pollForPairingToken, runConnection, setStorage, startPairing } from "@kubb/studio";
+//#region ../../internals/utils/src/fs.ts
+/**
+* Reads the file at `path` as a UTF-8 string.
+* Uses `Bun.file().text()` when running under Bun, `fs.readFile` otherwise.
+*
+* @example
+* ```ts
+* const source = await read('./src/Pet.ts')
+* ```
+*/
+async function read(path) {
+	if (runtime.isBun) return Bun.file(path).text();
+	return readFile(path, { encoding: "utf8" });
+}
+/**
+* Recursively removes `path`. Silently succeeds when `path` does not exist.
+*
+* @example
+* ```ts
+* await clean('./dist')
+* ```
+*/
+async function clean(path) {
+	return rm(path, {
+		recursive: true,
+		force: true
+	});
+}
+//#endregion
+//#region src/runners/studio/credentials.ts
+/**
+* Root for everything the CLI persists between runs: the paired credential, the machine secret,
+* the last Studio config, and the live-session registry. `KUBB_HOME` relocates all of it.
+*/
+function getKubbHome() {
+	return process.env.KUBB_HOME ?? path.join(homedir(), ".kubb");
+}
+const CREDENTIALS_FILENAME = "credentials.json";
+/**
+* Absolute path of the stored credential, so callers can name it in output without rebuilding it.
+*/
+function getCredentialsPath() {
+	return path.join(getKubbHome(), CREDENTIALS_FILENAME);
+}
+/**
+* Reads the stored credential, or null when this machine has not paired yet or the file is
+* unreadable or corrupt. A bad file is treated as "not paired" so `kubb studio login` can
+* overwrite it rather than the CLI dying on it.
+*/
+async function readCredentials() {
+	const raw = await read(getCredentialsPath()).catch(() => null);
+	if (!raw) return null;
+	try {
+		return JSON.parse(raw);
+	} catch {
+		return null;
+	}
+}
+/**
+* Writes the credential with owner-only permissions. The file holds a bearer token, so the mode
+* is set at creation time rather than left to the process umask or fixed up afterward, which
+* would leave the token briefly readable under the umask's default mode.
+*/
+async function writeCredentials(credentials) {
+	const file = getCredentialsPath();
+	await mkdir(path.dirname(file), {
+		recursive: true,
+		mode: 448
+	});
+	await writeFile(file, JSON.stringify(credentials, null, 2), { mode: 384 });
+}
+/**
+* Forgets the stored credential. Succeeds when there was nothing to forget.
+*/
+async function clearCredentials() {
+	await clean(getCredentialsPath());
+}
+//#endregion
+//#region src/runners/studio/run.ts
+const ACTIONS = [
+	"connect",
+	"login",
+	"logout",
+	"status"
+];
+/**
+* Opens a URL in the user's browser. Best effort: a failure just means the user follows the
+* printed link instead.
+*
+* `start` is a `cmd.exe` builtin, not an executable on PATH, so Windows runs it through `cmd`.
+* The empty string is the window-title argument `start` expects before the URL.
+*/
+async function openInBrowser(url) {
+	try {
+		if (process.platform === "win32") await x("cmd", [
+			"/c",
+			"start",
+			"",
+			url
+		]);
+		else await x(process.platform === "darwin" ? "open" : "xdg-open", [url]);
+	} catch {}
+}
+/**
+* Pairs this machine with Studio and stores the resulting token.
+*
+* The CLI holds a code and the browser approves it, rather than the user copying a token out of
+* the UI. The token comes back over the CLI's own HTTPS POST, so it never lands in a URL, a
+* server log, or a `Referer` header.
+*/
+async function login({ studioUrl, autoOpen }, { signal, previousCredentials } = {}) {
+	const session = await startPairing({
+		studioUrl,
+		name: path.basename(process.cwd()),
+		hostname: hostname(),
+		signal
+	});
+	console.log(`\nOpen ${styleText("cyan", session.verification_uri)} and approve the code ${styleText("bold", session.user_code)}`);
+	if (autoOpen) await openInBrowser(session.verification_uri_complete);
+	const spinner = createSpinner();
+	spinner.start("Waiting for approval");
+	try {
+		const { token, agent } = await pollForPairingToken({
+			studioUrl,
+			session,
+			signal
+		});
+		spinner.stop(`Paired as ${agent.name}`);
+		const keepsIdentity = previousCredentials?.studioUrl === studioUrl && previousCredentials.agentId === agent.id;
+		const credentials = {
+			studioUrl,
+			token,
+			agentId: agent.id,
+			agentSlug: agent.slug,
+			...keepsIdentity && previousCredentials?.projects ? { projects: previousCredentials.projects } : {}
+		};
+		await writeCredentials(credentials);
+		console.log(`Credentials stored in ${getCredentialsPath()}`);
+		return credentials;
+	} catch (error) {
+		spinner.stop(error instanceof PairingCanceledError ? "Pairing canceled" : "Pairing failed");
+		throw error;
+	}
+}
+/**
+* What each permission is asked as, in the order the questions appear.
+*/
+const PERMISSIONS = [
+	{
+		key: "allowWrite",
+		label: "write generated files",
+		question: (project) => `Let Kubb Studio write generated files into ${project}?`
+	},
+	{
+		key: "allowConfigEdit",
+		label: "edit kubb.config.ts",
+		question: (_project, configPath) => `Let Kubb Studio change plugin options in ${configPath}?`
+	},
+	{
+		key: "allowInput",
+		label: "use a Studio spec",
+		question: () => "Let Kubb Studio generate from an OpenAPI spec it sends, instead of the one on disk?"
+	},
+	{
+		key: "allowExec",
+		label: "run formatter, linter, postGenerate",
+		question: () => "Let Kubb Studio run the formatter, the linter, and output.postGenerate?"
+	}
+];
+/**
+* One row per permission, for the connect banner and `kubb studio status`. A list rather than a
+* joined line: four labels this long read as one run-on sentence side by side.
+*/
+function formatPermissionRows(granted) {
+	return PERMISSIONS.map(({ key, label }) => `${granted[key] ? styleText("green", "✔") : styleText("red", "✘")} ${label}`);
+}
+/**
+* Resolves Studio permissions for the current project.
+* Flags win, saved answers are reused, and new answers are stored unless `persist` is false.
+*/
+async function resolvePermissions(options, credentials, configPath = KUBB_CONFIG_FILENAME, persist = true) {
+	const project = process.cwd();
+	const remembered = credentials.projects?.[project];
+	const granted = {
+		allowWrite: false,
+		allowConfigEdit: false,
+		allowInput: false,
+		allowExec: false
+	};
+	const answers = {};
+	for (const { key, question } of PERMISSIONS) {
+		if (options.permission[key] || typeof remembered?.[key] === "boolean") {
+			granted[key] = options.permission[key] || remembered?.[key] === true;
+			continue;
+		}
+		if (isCIEnvironment() || !canUseTTY()) {
+			granted[key] = false;
+			continue;
+		}
+		granted[key] = await prompts.confirm({
+			message: question(project, configPath),
+			initialValue: false
+		}) === true;
+		answers[key] = granted[key];
+	}
+	if (persist && Object.keys(answers).length) await writeCredentials({
+		...credentials,
+		projects: {
+			...credentials.projects,
+			[project]: {
+				...remembered,
+				...answers
+			}
+		}
+	});
+	return granted;
+}
+/**
+* Loads the project's Kubb config the same way `kubb generate` does.
+* Returns the first config.
+*/
+async function loadConfigs(options) {
+	const { configPath, configs } = await getConfigs({
+		configPath: options.configPath,
+		logLevel: options.logLevel
+	});
+	const [config] = configs;
+	if (!config) throw new Error("Config not defined, create a kubb.config.ts or pass it with --config");
+	return {
+		configPath: path.relative(process.cwd(), configPath) || configPath,
+		config
+	};
+}
+/**
+* Explains a rejected token to the operator. Builds the error and nothing else, so each caller
+* decides what happens to the credentials.
+*/
+function explainRejectedToken(error, reason) {
+	if (reason === "envToken") return /* @__PURE__ */ new Error(`${error.message} Pair again and update KUBB_AGENT_TOKEN.`);
+	if (reason === "reauthExhausted") return /* @__PURE__ */ new Error(`${error.message} Studio rejected the newly approved token too. Run \`kubb studio login\` and try again.`);
+	return /* @__PURE__ */ new Error(`${error.message} Run \`kubb studio login\` to pair again.`);
+}
+/**
+* One `kubb studio` connect run: pairing if needed, connecting, and pairing again whenever Studio
+* rejects the token. Reached through `connect()`, which is what the command runs.
+*/
+var StudioConnection = class {
+	#options;
+	#configPath;
+	#shutdown = new AbortController();
+	#requestShutdown = () => this.#shutdown.abort();
+	#processEvents = process;
+	#credentials;
+	#hinted = false;
+	#hasReauthenticated = false;
+	#granted;
+	constructor(options, configPath) {
+		this.#options = options;
+		this.#configPath = configPath;
+	}
+	#reportDisconnected() {
+		if (this.#options.logLevel === "silent") return;
+		logOutro("Disconnected");
+	}
+	/**
+	* Connects and streams generation events until the process is stopped or Studio rejects the
+	* token.
+	*
+	* One `AbortController` covers the whole run: it cancels an in-flight pairing poll on Ctrl+C and
+	* ends the wait in `#connectAndWait`. Its signal listeners are armed once here, so a retried
+	* pairing cannot leave a duplicate behind.
+	*/
+	async run() {
+		this.#processEvents.once("SIGINT", this.#requestShutdown);
+		this.#processEvents.once("SIGTERM", this.#requestShutdown);
+		try {
+			this.#credentials = await this.#resolveInitialCredentials();
+			this.#granted = await resolvePermissions(this.#options, this.#credentials, this.#configPath, !process.env.KUBB_AGENT_TOKEN);
+			this.#printBanner();
+			if (await runConnection({
+				credentials: this.#credentials,
+				signal: this.#shutdown.signal,
+				clientOptions: () => this.#clientOptions(),
+				onTokenRejected: ({ error, live }) => this.#handleRejection(error, live)
+			}) === "shutdown") this.#reportDisconnected();
+		} catch (error) {
+			if (error instanceof PairingCanceledError) return;
+			throw error;
+		} finally {
+			this.#processEvents.off("SIGINT", this.#requestShutdown);
+			this.#processEvents.off("SIGTERM", this.#requestShutdown);
+		}
+	}
+	async #resolveInitialCredentials() {
+		const envToken = process.env.KUBB_AGENT_TOKEN;
+		const stored = envToken ? null : await readCredentials();
+		const resolved = envToken ? {
+			studioUrl: this.#options.studioUrl,
+			token: envToken,
+			agentId: "",
+			agentSlug: ""
+		} : stored?.studioUrl === this.#options.studioUrl ? stored : null;
+		if (resolved) return resolved;
+		if (isCIEnvironment()) throw new Error(`Not paired with ${this.#options.studioUrl}. Set KUBB_AGENT_TOKEN, or run \`kubb studio login\` on a machine with a browser.`);
+		return login(this.#options, { signal: this.#shutdown.signal });
+	}
+	#printBanner() {
+		if (this.#options.logLevel === "silent") return;
+		const detail = (label, value) => `${styleText("dim", label.padEnd(7))}  ${value}`;
+		logBlock([
+			detail("Studio", styleText("cyan", this.#options.studioUrl)),
+			detail("Project", path.basename(process.cwd())),
+			detail("Config", path.relative(process.cwd(), this.#configPath) || this.#configPath),
+			"",
+			styleText("dim", "Permissions"),
+			...formatPermissionRows(this.#granted)
+		]);
+	}
+	/**
+	* What every connection attempt opens with. Rebuilt per attempt, so a re-pair that changed the
+	* granted permissions takes effect on the next one.
+	*/
+	#clientOptions() {
+		return {
+			studioUrl: this.#options.studioUrl,
+			configPath: this.#configPath,
+			version: this.#options.version,
+			loadConfig: async () => (await loadConfigs(this.#options)).config,
+			client: { kind: "cli" },
+			root: process.cwd(),
+			permissions: this.#granted,
+			installLogger: async (hooks) => {
+				await setupReporters(hooks, {
+					logLevel: logLevel[this.#options.logLevel ?? "info"],
+					reporters: [cliReporter]
+				});
+				hooks.hook("studio:connected", () => {
+					if (this.#hinted || this.#options.logLevel === "silent") return;
+					this.#hinted = true;
+					logBlock(styleText("dim", "Press Ctrl+C to disconnect"));
+				});
+			}
+		};
+	}
+	/**
+	* Throws when a rejected token cannot be replaced by pairing again: this run already paired once
+	* and was rejected anyway, or there is no browser to approve a new pairing.
+	*/
+	#assertCanReauthenticate(error) {
+		if (this.#hasReauthenticated) throw explainRejectedToken(error, "reauthExhausted");
+		if (isCIEnvironment() || !canUseTTY()) throw explainRejectedToken(error, "nonInteractive");
+	}
+	/**
+	* Studio rejected the token, either before a session ever opened or once one was already live.
+	* Keeping a rejected token only produces 401s on every run, so it is forgotten and paired again.
+	* Returns the credential to reconnect with, or null when the run is over.
+	*/
+	async #handleRejection(error, live) {
+		if (process.env.KUBB_AGENT_TOKEN) throw explainRejectedToken(error, "envToken");
+		if (!live) await clearCredentials();
+		this.#assertCanReauthenticate(error);
+		console.log(styleText("yellow", live ? `${error.message} Studio needs you to approve access again.` : `${error.message} Pairing again...`));
+		if (live) await clearCredentials();
+		const credentials = await this.#reauthenticate();
+		if (!credentials && live) this.#reportDisconnected();
+		return credentials;
+	}
+	/**
+	* Re-pairs and stores the resulting credentials. Returns null when the operator canceled it.
+	*/
+	async #reauthenticate() {
+		try {
+			this.#credentials = await login(this.#options, {
+				signal: this.#shutdown.signal,
+				previousCredentials: this.#credentials
+			});
+		} catch (loginError) {
+			if (loginError instanceof PairingCanceledError) return null;
+			throw loginError;
+		}
+		this.#hasReauthenticated = true;
+		this.#granted = await resolvePermissions(this.#options, this.#credentials, this.#configPath, !process.env.KUBB_AGENT_TOKEN);
+		return this.#credentials;
+	}
+};
+/**
+* Connects this project to Studio and streams generation events until the process is stopped or
+* Studio rejects the token.
+*/
+async function connect(options) {
+	const { configPath } = await loadConfigs(options);
+	await new StudioConnection(options, configPath).run();
+}
+/**
+* Reports the paired agent and any saved permissions for the current project.
+*/
+async function status(options) {
+	const credentials = await readCredentials();
+	if (!credentials) {
+		console.log("Not paired. Run `kubb studio login`.");
+		return;
+	}
+	console.log(`Paired with ${credentials.studioUrl} as ${styleText("cyan", credentials.agentSlug || credentials.agentId)}`);
+	if (credentials.studioUrl !== options.studioUrl) console.log(styleText("yellow", `Connecting to ${options.studioUrl} needs pairing again.`));
+	const remembered = credentials.projects?.[process.cwd()];
+	if (!remembered) {
+		console.log(styleText("dim", "No saved permissions for this project. Run `kubb studio` to connect and choose."));
+		return;
+	}
+	console.log(styleText("dim", "Saved permissions"));
+	for (const row of formatPermissionRows({
+		allowWrite: remembered.allowWrite === true,
+		allowConfigEdit: remembered.allowConfigEdit === true,
+		allowInput: remembered.allowInput === true,
+		allowExec: remembered.allowExec === true
+	})) console.log(row);
+}
+/**
+* Runs a `kubb studio` action and reports the outcome to telemetry.
+*/
+async function run(options) {
+	setStorage(createFileStorage(path.join(getKubbHome(), "cache")));
+	const hrStart = process.hrtime();
+	const report = (status) => sendTelemetry(buildTelemetryEvent({
+		command: "studio",
+		kubbVersion: options.version,
+		hrStart,
+		status
+	}));
+	try {
+		if (options.logLevel !== "silent") logIntro({
+			title: `Kubb Studio  ${styleText("dim", `v${options.version}`)}`,
+			warning: styleText("yellow", "This feature is still under development, use with caution"),
+			block: options.action === "connect"
+		});
+		switch (options.action) {
+			case "login":
+				await login(options);
+				break;
+			case "logout":
+				await clearCredentials();
+				console.log("Signed out of Kubb Studio.");
+				break;
+			case "status":
+				await status(options);
+				break;
+			case "connect":
+				await connect(options);
+				break;
+			default: throw new Error(`Unknown action "${options.action}", expected one of ${ACTIONS.join(", ")}`);
+		}
+		await report("success");
+	} catch (error) {
+		await report("failed");
+		console.error(toError(error).message);
+		process.exitCode = 1;
+	}
+}
+/**
+* Maps the parsed `kubb studio` flags onto {@link run}. Loaded on demand by `index.ts`, so the
+* Studio client stays out of the process for every other command.
+*/
+const runner = async ({ values }) => {
+	await run({
+		action: values.action ?? "connect",
+		version,
+		configPath: values.config,
+		studioUrl: values.url ?? defaultStudioUrl,
+		permission: {
+			allowWrite: values.allowWrite,
+			allowConfigEdit: values.allowConfigEdit,
+			allowInput: values.allowInput,
+			allowExec: values.allowExec
+		},
+		autoOpen: values.open,
+		logLevel: values.logLevel
+	});
+};
+//#endregion
+export { runner };
+
+//# sourceMappingURL=run-DUY0lV8l.js.map