@drakulavich/kesha-voice-kit 1.24.7 → 1.25.0

package/README.md

@@ -57,6 +57,7 @@ kesha --json --timestamps audio.ogg        # JSON with timestamped segments
 kesha --toon audio.ogg                     # compact LLM-friendly TOON
 kesha status                               # show installed backend info
 kesha status --disk                        # + recursive cache disk usage
+kesha status --json                        # machine-readable, for scripts
 ```
 
 Multiple files get `head`-style headers; stdout is the transcript, stderr is errors — pipe-friendly:

package/completions/kesha.bash

@@ -28,7 +28,7 @@ _kesha_completion() {
     record) opts="--help -h --out --max-seconds --debug" ;;
     say) opts="--help -h --voice --lang --out --rate --list-voices --ssml --format --bitrate --sample-rate --no-expand-abbrev --verbose --debug" ;;
     stats) opts="--help -h --format" ;;
-    status) opts="--help -h --disk" ;;
+    status) opts="--help -h --disk --json" ;;
     support-bundle) opts="--help -h --output --include-logs" ;;
     *) opts="--help -h --version -v --json --toon --timestamps --speakers --include-errors --verbose --format --lang --debug --vad --no-vad --quiet --no-color" ;;
   esac

package/completions/kesha.fish

@@ -86,6 +86,7 @@ complete -c kesha -n '__fish_seen_subcommand_from stats' -l format -r -d 'Export
 complete -c kesha -n '__fish_seen_subcommand_from status' -l help -d 'Show help'
 complete -c kesha -n '__fish_seen_subcommand_from status' -s h -d 'Show help'
 complete -c kesha -n '__fish_seen_subcommand_from status' -l disk -d 'Include recursive cache disk usage'
+complete -c kesha -n '__fish_seen_subcommand_from status' -l json -d 'Output status as JSON'
 complete -c kesha -n '__fish_seen_subcommand_from support-bundle' -l help -d 'Show help'
 complete -c kesha -n '__fish_seen_subcommand_from support-bundle' -s h -d 'Show help'
 complete -c kesha -n '__fish_seen_subcommand_from support-bundle' -l output -r -d 'Write archive to this .tar.gz path'

package/completions/kesha.zsh

@@ -121,7 +121,8 @@ _kesha() {
     status)
       _arguments '--help[Show help]' \
         '-h[Show help]' \
-        '--disk[Include recursive cache disk usage]'
+        '--disk[Include recursive cache disk usage]' \
+        '--json[Output status as JSON]'
       ;;
     support-bundle)
       _arguments '--help[Show help]' \

package/man/kesha.1

@@ -200,6 +200,9 @@ Export format: json | csv
 .TP
 .B \-\-disk
 Include recursive cache disk usage
+.TP
+.B \-\-json
+Output status as JSON
 .SS support-bundle
 .TP
 .B \-\-output

package/model-plan.json

@@ -0,0 +1,43 @@
+{
+  "asr": [
+    { "relPath": "models/parakeet-tdt-v3/encoder-model.onnx", "sizeBytes": 41770866 },
+    { "relPath": "models/parakeet-tdt-v3/encoder-model.onnx.data", "sizeBytes": 2435420160 },
+    { "relPath": "models/parakeet-tdt-v3/decoder_joint-model.onnx", "sizeBytes": 72520893 },
+    { "relPath": "models/parakeet-tdt-v3/nemo128.onnx", "sizeBytes": 139764 },
+    { "relPath": "models/parakeet-tdt-v3/vocab.txt", "sizeBytes": 93939 }
+  ],
+  "langId": [
+    { "relPath": "models/lang-id-ecapa/lang-id-ecapa.onnx", "sizeBytes": 759814 },
+    { "relPath": "models/lang-id-ecapa/lang-id-ecapa.onnx.data", "sizeBytes": 85327872 },
+    { "relPath": "models/lang-id-ecapa/labels.json", "sizeBytes": 646 }
+  ],
+  "vad": [
+    { "relPath": "models/silero-vad/silero_vad.onnx", "sizeBytes": 2327524 }
+  ],
+  "g2pCharsiu": [
+    { "relPath": "models/g2p/byt5-tiny/encoder_model.onnx", "sizeBytes": 12478704 },
+    { "relPath": "models/g2p/byt5-tiny/decoder_model.onnx", "sizeBytes": 11983268 },
+    { "relPath": "models/g2p/byt5-tiny/decoder_with_past_model.onnx", "sizeBytes": 5427260 }
+  ],
+  "kokoroGraph": { "relPath": "models/kokoro-82m/model.onnx", "sizeBytes": 325532387 },
+  "kokoroVoices": {
+    "en": { "relPath": "models/kokoro-82m/voices/am_michael.bin", "sizeBytes": 522240 },
+    "es": { "relPath": "models/kokoro-82m/voices/em_alex.bin", "sizeBytes": 522240 },
+    "fr": { "relPath": "models/kokoro-82m/voices/ff_siwis.bin", "sizeBytes": 522240 },
+    "it": { "relPath": "models/kokoro-82m/voices/im_nicola.bin", "sizeBytes": 522240 },
+    "pt": { "relPath": "models/kokoro-82m/voices/pm_alex.bin", "sizeBytes": 522240 }
+  },
+  "voskRu": [
+    { "relPath": "models/vosk-ru/model.onnx", "sizeBytes": 179314533 },
+    { "relPath": "models/vosk-ru/dictionary", "sizeBytes": 101431118 },
+    { "relPath": "models/vosk-ru/config.json", "sizeBytes": 1518 },
+    { "relPath": "models/vosk-ru/bert/model.onnx", "sizeBytes": 654361598 },
+    { "relPath": "models/vosk-ru/bert/vocab.txt", "sizeBytes": 1780720 }
+  ],
+  "diarize": [
+    { "relPath": "models/diarize/SortformerNvidiaLow_v2.mlpackage/Manifest.json", "sizeBytes": 617 },
+    { "relPath": "models/diarize/SortformerNvidiaLow_v2.mlpackage/Data/com.apple.CoreML/model.mlmodel", "sizeBytes": 7080357 },
+    { "relPath": "models/diarize/SortformerNvidiaLow_v2.mlpackage/Data/com.apple.CoreML/weights/0-weight.bin", "sizeBytes": 5930400 },
+    { "relPath": "models/diarize/SortformerNvidiaLow_v2.mlpackage/Data/com.apple.CoreML/weights/1-weight.bin", "sizeBytes": 232161600 }
+  ]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@drakulavich/kesha-voice-kit",
-  "version": "1.24.7",
+  "version": "1.25.0",
   "description": "Give your tools a voice — speech to text and back, 25 languages, up to ~19× faster than Whisper. On your machine.",
   "type": "module",
   "bin": {
@@ -15,6 +15,7 @@
     "completions/",
     "man/",
     "src/",
+    "model-plan.json",
     "package.json",
     "tsconfig.json",
     "openclaw.plugin.json",
@@ -43,7 +44,7 @@
   "scripts": {
     "test": "bun test --timeout 30000",
     "test:watch": "bun test --timeout 30000 --watch",
-    "test:unit": "bun test tests/unit/",
+    "test:unit": "bun test --timeout 30000 tests/unit/",
     "test:cli-fast": "bun test --timeout 30000 tests/unit/ tests/integration/cli-contracts.test.ts tests/integration/e2e-cli.test.ts tests/integration/say.test.ts",
     "test:integration": "bun test --timeout 30000 tests/integration/",
     "coverage:ts": "bun run test:cli-fast --coverage --coverage-reporter=text --coverage-reporter=lcov --coverage-dir=coverage/ts",
@@ -92,7 +93,7 @@
   "dependencies": {
     "@clack/prompts": "^1.5.0",
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@toon-format/toon": "^2.1.0",
+    "@toon-format/toon": "^4.1.0",
     "citty": "^0.2.2",
     "fastest-levenshtein": "^1.0.16",
     "picocolors": "^1.1.1",

package/src/cli/status.ts

@@ -1,8 +1,9 @@
 import { defineCommand } from "citty";
-import { showStatus } from "../status";
+import { collectStatus, renderStatus } from "../status";
 
 interface StatusCommandArgs {
   disk: boolean;
+  json: boolean;
 }
 
 export const statusCommand = defineCommand({
@@ -16,8 +17,20 @@ export const statusCommand = defineCommand({
       description: "Include recursive cache disk usage",
       default: false,
     },
+    json: {
+      type: "boolean",
+      description: "Output status as JSON",
+      default: false,
+    },
   },
   async run({ args }: { args: StatusCommandArgs }) {
-    await showStatus({ disk: args.disk });
+    const report = await collectStatus({ disk: args.disk });
+    if (args.json) {
+      // `log.*` writes to stdout, so the payload must be the only thing printed —
+      // the setup hint ships inside it instead of on stderr (#647).
+      console.log(JSON.stringify(report, null, 2));
+      return;
+    }
+    renderStatus(report);
   },
 });

package/src/engine.ts

@@ -364,10 +364,23 @@ export async function getEngineCapabilities(): Promise<EngineCapabilities | null
   const { stdout, exitCode } = await runEngine(["--capabilities-json"]);
   if (exitCode !== 0) return null;
   try {
-    const capabilities = JSON.parse(stdout) as EngineCapabilities;
+    const capabilities = parseCapabilities(JSON.parse(stdout));
+    if (!capabilities) return null;
     cachedEngineCapabilities = { binPath, mtime, capabilities };
     return capabilities;
   } catch {
     return null;
   }
 }
+
+// A non-null return has to mean "the engine described itself" — callers reach
+// straight for `.features.join()` and `.backend` (#647). Only the fields those
+// callers consume are checked, so a newer engine adding fields still validates.
+function parseCapabilities(parsed: unknown): EngineCapabilities | null {
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+  const { protocolVersion, backend, features } = parsed as Record<string, unknown>;
+  if (typeof protocolVersion !== "number") return null;
+  if (typeof backend !== "string") return null;
+  if (!Array.isArray(features) || features.some((f) => typeof f !== "string")) return null;
+  return parsed as EngineCapabilities;
+}

package/src/install-plan.ts

@@ -11,6 +11,7 @@ import {
   fluidKokoroCachePath,
   isDarwinArm64,
 } from "./fluid-kokoro-cache";
+import modelPlan from "../model-plan.json" with { type: "json" };
 
 export interface InstallPlanOptions {
   noCache?: boolean;
@@ -26,6 +27,17 @@ interface PlanFile {
   sizeBytes: number;
 }
 
+interface ModelPlan {
+  asr: PlanFile[];
+  langId: PlanFile[];
+  vad: PlanFile[];
+  g2pCharsiu: PlanFile[];
+  kokoroGraph: PlanFile;
+  kokoroVoices: Record<string, PlanFile>;
+  voskRu: PlanFile[];
+  diarize: PlanFile[];
+}
+
 interface PlanComponent {
   name: string;
   source: string;
@@ -45,46 +57,19 @@ interface ReleaseAssetSpec {
   sizeBytes: number;
 }
 
-// Mirrors the pinned runtime manifests so `kesha install --plan` works before
-// the engine exists. Keep in sync with rust/src/models.rs and release assets.
-const ASR_FILES: PlanFile[] = [
-  { relPath: "models/parakeet-tdt-v3/encoder-model.onnx", sizeBytes: 41_770_866 },
-  { relPath: "models/parakeet-tdt-v3/encoder-model.onnx.data", sizeBytes: 2_435_420_160 },
-  { relPath: "models/parakeet-tdt-v3/decoder_joint-model.onnx", sizeBytes: 72_520_893 },
-  { relPath: "models/parakeet-tdt-v3/nemo128.onnx", sizeBytes: 139_764 },
-  { relPath: "models/parakeet-tdt-v3/vocab.txt", sizeBytes: 93_939 },
-];
-
-const LANG_ID_FILES: PlanFile[] = [
-  { relPath: "models/lang-id-ecapa/lang-id-ecapa.onnx", sizeBytes: 759_814 },
-  { relPath: "models/lang-id-ecapa/lang-id-ecapa.onnx.data", sizeBytes: 85_327_872 },
-  { relPath: "models/lang-id-ecapa/labels.json", sizeBytes: 646 },
-];
-
-const VAD_FILES: PlanFile[] = [
-  { relPath: "models/silero-vad/silero_vad.onnx", sizeBytes: 2_327_524 },
-];
-
-// klebster CharsiuG2P byt5-tiny ONNX export (CC-BY 4.0 — see NOTICES.md). Multilingual G2P for es/fr/it/pt (#212).
-const G2P_CHARSIU_FILES: PlanFile[] = [
-  { relPath: "models/g2p/byt5-tiny/encoder_model.onnx", sizeBytes: 12_478_704 },
-  { relPath: "models/g2p/byt5-tiny/decoder_model.onnx", sizeBytes: 11_983_268 },
-  { relPath: "models/g2p/byt5-tiny/decoder_with_past_model.onnx", sizeBytes: 5_427_260 },
-];
-
-// Kokoro ONNX graph (shared by all Kokoro languages on non-darwin builds).
-const KOKORO_GRAPH_FILE: PlanFile = { relPath: "models/kokoro-82m/model.onnx", sizeBytes: 325_532_387 };
-
-// Multilingual voice packs for es/fr/it/pt (#212).
-// em_alex (es, male), ff_siwis (fr, female — only French voice in Kokoro v1.0),
-// im_nicola (it, male), pm_alex (pt, male).
-const KOKORO_VOICE_FILES: Record<string, PlanFile> = {
-  en: { relPath: "models/kokoro-82m/voices/am_michael.bin", sizeBytes: 522_240 },
-  es: { relPath: "models/kokoro-82m/voices/em_alex.bin", sizeBytes: 522_240 },
-  fr: { relPath: "models/kokoro-82m/voices/ff_siwis.bin", sizeBytes: 522_240 },
-  it: { relPath: "models/kokoro-82m/voices/im_nicola.bin", sizeBytes: 522_240 },
-  pt: { relPath: "models/kokoro-82m/voices/pm_alex.bin", sizeBytes: 522_240 },
-};
+// Shared plan metadata keeps `kesha install --plan` usable before the engine
+// exists. Rust tests guard these cache paths against its pinned manifests.
+const plan: ModelPlan = modelPlan;
+const {
+  asr: ASR_FILES,
+  langId: LANG_ID_FILES,
+  vad: VAD_FILES,
+  g2pCharsiu: G2P_CHARSIU_FILES,
+  kokoroGraph: KOKORO_GRAPH_FILE,
+  kokoroVoices: KOKORO_VOICE_FILES,
+  voskRu: VOSK_RU_FILES,
+  diarize: DIARIZE_FILES,
+} = plan;
 
 function kokoroPlanFiles(langs: string[]): PlanFile[] {
   const files: PlanFile[] = [KOKORO_GRAPH_FILE];
@@ -95,30 +80,6 @@ function kokoroPlanFiles(langs: string[]): PlanFile[] {
   return files;
 }
 
-const VOSK_RU_FILES: PlanFile[] = [
-  { relPath: "models/vosk-ru/model.onnx", sizeBytes: 179_314_533 },
-  { relPath: "models/vosk-ru/dictionary", sizeBytes: 101_431_118 },
-  { relPath: "models/vosk-ru/config.json", sizeBytes: 1_518 },
-  { relPath: "models/vosk-ru/bert/model.onnx", sizeBytes: 654_361_598 },
-  { relPath: "models/vosk-ru/bert/vocab.txt", sizeBytes: 1_780_720 },
-];
-
-const DIARIZE_FILES: PlanFile[] = [
-  { relPath: "models/diarize/SortformerNvidiaLow_v2.mlpackage/Manifest.json", sizeBytes: 617 },
-  {
-    relPath: "models/diarize/SortformerNvidiaLow_v2.mlpackage/Data/com.apple.CoreML/model.mlmodel",
-    sizeBytes: 7_080_357,
-  },
-  {
-    relPath: "models/diarize/SortformerNvidiaLow_v2.mlpackage/Data/com.apple.CoreML/weights/0-weight.bin",
-    sizeBytes: 5_930_400,
-  },
-  {
-    relPath: "models/diarize/SortformerNvidiaLow_v2.mlpackage/Data/com.apple.CoreML/weights/1-weight.bin",
-    sizeBytes: 232_161_600,
-  },
-];
-
 // The sidecar list (and the asset-name → installed-filename mapping) lives in
 // SIDECARS in engine-install.ts; only the release-asset sizes are pinned here,
 // like the model tables above.

package/src/status.ts

@@ -1,8 +1,14 @@
 import { readdirSync, statSync } from "fs";
 import { join } from "path";
-import { isEngineInstalled, getEngineBinPath, getEngineCapabilities } from "./engine";
+import {
+  isEngineInstalled,
+  getEngineBinPath,
+  getEngineCapabilities,
+  type EngineCapabilities,
+} from "./engine";
 import { installHint } from "./install-hint";
 import { log } from "./log";
+import { packageVersion } from "./package-info";
 import { keshaCacheDir } from "./paths";
 import { fluidKokoroCacheInfo } from "./fluid-kokoro-cache";
 import { dirSizeBytes } from "./diagnostic-paths";
@@ -35,8 +41,60 @@ export interface ShowStatusOptions {
   disk?: boolean;
 }
 
-async function logEngineCapabilities(): Promise<void> {
-  const caps = await getEngineCapabilities().catch(() => null);
+export interface StatusDiskComponent {
+  label: string;
+  sizeBytes: number;
+}
+
+export interface StatusDiskUsage {
+  cachePath: string;
+  components: StatusDiskComponent[];
+  componentTotalBytes: number;
+  totalBytes: number;
+  fluidKokoro: { path: string; sizeBytes: number } | null;
+}
+
+/**
+ * Machine-readable `kesha status` payload (#647). Contract: every key is always
+ * present — absent values are null (or `[]` for voices), never omitted, so a
+ * consumer never distinguishes a missing key from a null value. `engine.installed`
+ * reports only that a binary exists; usability additionally requires
+ * `engine.capabilities` to be non-null.
+ */
+export interface StatusReport {
+  cliVersion: string;
+  engine: {
+    installed: boolean;
+    path: string;
+    capabilities: EngineCapabilities | null;
+  };
+  voices: string[];
+  runtime: { bun: string; platform: string; arch: string };
+  modelMirror: string | null;
+  hint: string | null;
+  disk: StatusDiskUsage | null;
+}
+
+export async function collectStatus(options: ShowStatusOptions = {}): Promise<StatusReport> {
+  const path = getEngineBinPath();
+  const installed = isEngineInstalled();
+  const capabilities = installed ? await getEngineCapabilities().catch(() => null) : null;
+
+  return {
+    cliVersion: packageVersion,
+    engine: { installed, path, capabilities },
+    voices: installed ? listInstalledVoices() : [],
+    runtime: { bun: Bun.version, platform: process.platform, arch: process.arch },
+    modelMirror: activeModelMirror(),
+    hint: installed
+      ? null
+      : `Run \`${installHint()}\` to download the engine and models.`,
+    // Absent engine means no disk walk, matching the human path (#647).
+    disk: installed && options.disk ? collectDiskUsage(path) : null,
+  };
+}
+
+function logEngineCapabilities(caps: EngineCapabilities | null): void {
   if (caps) {
     log.info(formatStatusLine("Backend", caps.backend, true));
     log.info(formatStatusLine("Protocol", `v${caps.protocolVersion}`, true));
@@ -46,8 +104,7 @@ async function logEngineCapabilities(): Promise<void> {
   }
 }
 
-function logInstalledVoices(): void {
-  const voices = listInstalledVoices();
+function logInstalledVoices(voices: string[]): void {
   if (voices.length === 0) return;
   log.info("TTS voices:");
   for (const v of voices) {
@@ -56,40 +113,37 @@ function logInstalledVoices(): void {
   log.info("");
 }
 
-export async function showStatus(options: ShowStatusOptions = {}): Promise<void> {
-  const binPath = getEngineBinPath();
-  const installed = isEngineInstalled();
+export function renderStatus(report: StatusReport): void {
+  const { installed, path, capabilities } = report.engine;
 
   log.info("Engine:");
-  log.info(formatStatusLine("Binary", installed ? binPath : null, installed));
+  log.info(formatStatusLine("Binary", installed ? path : null, installed));
 
   if (installed) {
-    await logEngineCapabilities();
+    logEngineCapabilities(capabilities);
   }
   log.info("");
 
-  log.info(formatStatusLine("Runtime", `Bun ${Bun.version}`, true));
-  log.info(formatStatusLine("Platform", `${process.platform} ${process.arch}`, true));
-  const mirror = activeModelMirror();
-  if (mirror) {
-    log.info(formatStatusLine("Mirror", mirror, true));
+  log.info(formatStatusLine("Runtime", `Bun ${report.runtime.bun}`, true));
+  log.info(
+    formatStatusLine("Platform", `${report.runtime.platform} ${report.runtime.arch}`, true),
+  );
+  if (report.modelMirror) {
+    log.info(formatStatusLine("Mirror", report.modelMirror, true));
   }
   log.info("");
 
   if (installed) {
-    logInstalledVoices();
-
-    if (options.disk) {
-      showDiskUsage(binPath);
-    }
+    logInstalledVoices(report.voices);
+    if (report.disk) showDiskUsage(report.disk);
   }
 
-  if (!installed) {
-    log.warn(`Run \`${installHint()}\` to download the engine and models.`);
-    return;
+  if (report.hint) {
+    log.warn(report.hint);
   }
 }
 
+
 function buildDiskComponents(cache: string, engineDir: string): Array<{ label: string; path: string }> {
   return [
     { label: "Engine", path: engineDir },
@@ -101,11 +155,11 @@ function buildDiskComponents(cache: string, engineDir: string): Array<{ label: s
   ];
 }
 
-function logDiskRows(rows: Array<{ label: string; size: number }>, total: number, componentTotal: number): void {
+function logDiskRows(rows: StatusDiskComponent[], total: number, componentTotal: number): void {
   const labelWidth = Math.max(...rows.map((r) => r.label.length), "Total".length);
   for (const r of rows) {
     const pad = " ".repeat(labelWidth - r.label.length + 2);
-    log.info(`  ${r.label}:${pad}${humanBytes(r.size)}`);
+    log.info(`  ${r.label}:${pad}${humanBytes(r.sizeBytes)}`);
   }
   const totalPad = " ".repeat(labelWidth - "Total".length + 2);
   log.info(`  ${pc.bold("Total")}:${totalPad}${pc.bold(humanBytes(total))}`);
@@ -115,42 +169,51 @@ function logDiskRows(rows: Array<{ label: string; size: number }>, total: number
   }
 }
 
-function logFluidKokoroCache(): void {
-  const fluidKokoro = fluidKokoroCacheInfo();
-  if (!fluidKokoro.exists || fluidKokoro.sizeBytes <= 0) return;
+function logFluidKokoroCache(fluidKokoro: StatusDiskUsage["fluidKokoro"]): void {
+  if (!fluidKokoro) return;
   log.info("");
   log.info(`External caches (not included in Kesha total):`);
   log.info(`  FluidAudio Kokoro: ${humanBytes(fluidKokoro.sizeBytes)} (${fluidKokoro.path})`);
 }
 
-function showDiskUsage(binPath: string): void {
+function collectDiskUsage(binPath: string): StatusDiskUsage {
   const cache = keshaCacheDir();
   // Two levels up from the binary (`<cache>/engine/bin/`) so future engine-root siblings are counted.
   const engineDir = join(binPath, "..", "..");
 
-  const components = buildDiskComponents(cache, engineDir);
-
-  const rows: Array<{ label: string; size: number }> = [];
-  for (const c of components) {
-    const size = dirSizeBytes(c.path);
-    if (size > 0) rows.push({ label: c.label, size });
+  const components: StatusDiskComponent[] = [];
+  for (const c of buildDiskComponents(cache, engineDir)) {
+    const sizeBytes = dirSizeBytes(c.path);
+    if (sizeBytes > 0) components.push({ label: c.label, sizeBytes });
   }
 
-  if (rows.length === 0) return;
-
   // Sum cache root + engine dir separately so `KESHA_ENGINE_BIN` overrides outside the cache are still counted.
-  const componentTotal = rows.reduce((n, r) => n + r.size, 0);
   const cacheTotal = dirSizeBytes(cache);
-  const engineOutsideCache = engineDir.startsWith(cache)
-    ? 0
-    : dirSizeBytes(engineDir);
-  const total = cacheTotal + engineOutsideCache;
-
-  log.info(`Disk usage (${cache}):`);
-  logDiskRows(rows, total, componentTotal);
-  logFluidKokoroCache();
+  const engineOutsideCache = engineDir.startsWith(cache) ? 0 : dirSizeBytes(engineDir);
+  const fluidKokoro = fluidKokoroCacheInfo();
+
+  return {
+    cachePath: cache,
+    components,
+    componentTotalBytes: components.reduce((n, c) => n + c.sizeBytes, 0),
+    totalBytes: cacheTotal + engineOutsideCache,
+    fluidKokoro:
+      fluidKokoro.exists && fluidKokoro.sizeBytes > 0
+        ? { path: fluidKokoro.path, sizeBytes: fluidKokoro.sizeBytes }
+        : null,
+  };
+}
+
+function showDiskUsage(disk: StatusDiskUsage): void {
+  if (disk.components.length === 0) return;
+
+  log.info(`Disk usage (${disk.cachePath}):`);
+  logDiskRows(disk.components, disk.totalBytes, disk.componentTotalBytes);
+  logFluidKokoroCache(disk.fluidKokoro);
   log.info("");
-  log.info(pc.dim(`  To reset cache: rm -rf ${cache} — next \`kesha install\` re-downloads.`));
+  log.info(
+    pc.dim(`  To reset cache: rm -rf ${disk.cachePath} — next \`kesha install\` re-downloads.`),
+  );
   log.info("");
 }