@drakulavich/kesha-voice-kit 1.0.10 → 1.2.0

package/README.md

@@ -13,14 +13,18 @@
 
 <p align="center"><b>Open-source voice toolkit.</b> Optimized for Apple Silicon (CoreML), works on any platform (ONNX fallback).<br>A collection of small, fast, open-source audio models — packaged as CLI tools and an <a href="https://github.com/openclaw/openclaw">OpenClaw</a> skill for LLM agents.</p>
 
-- **Speech-to-text** — 25 languages, ~19x faster than Whisper on Apple Silicon, ~2.5x on CPU
+- **Speech-to-text** — 25 languages, ~15x faster than Whisper on Apple Silicon, ~2.5x on CPU
 - **Language detection** — 107 languages from audio, text language via NLLanguageRecognizer
 - **Rust engine** — single 20MB binary, no ffmpeg, no Python, no native Node addons
 - **OpenClaw-ready** — plug into your LLM agent as a voice processing skill
 
 ## Quick Start
 
+Runtime: **[Bun](https://bun.sh)** >= 1.3.0.
+
 ```bash
+curl -fsSL https://bun.sh/install | bash   # skip if Bun is already installed
+
 bun install -g @drakulavich/kesha-voice-kit
 kesha install       # downloads engine + models
 kesha audio.ogg     # transcript to stdout
@@ -30,27 +34,19 @@ kesha audio.ogg     # transcript to stdout
 
 Kesha Voice Kit ships as a plugin for [OpenClaw](https://github.com/openclaw/openclaw) — give your LLM agent ears. No API keys, everything runs locally on your machine.
 
-**Install the `kesha` CLI first** (the plugin shells out to it):
-
-```bash
-bun add -g @drakulavich/kesha-voice-kit
-kesha install
-```
-
-**Then configure OpenClaw to use Kesha for audio transcription:**
-
 ```bash
+bun add -g @drakulavich/kesha-voice-kit && kesha install
 openclaw plugins install @drakulavich/kesha-voice-kit
 openclaw config set tools.media.audio.models \
   '[{"type":"cli","command":"kesha","args":["--format","transcript","{{MediaPath}}"],"timeoutSeconds":15}]'
-openclaw config set tools.media.audio.enabled true
-openclaw gateway restart
 ```
 
+> If audio transcription is not already enabled: `openclaw config set tools.media.audio.enabled true`
+
 Your agent receives a voice message in Telegram/WhatsApp/Slack, Kesha transcribes it locally, and the agent sees enriched context:
 
 ```
-Привет, как дела?
+Таити, Таити! Не были мы ни в какой Таити! Нас и тут неплохо кормят.
 [lang: ru, confidence: 1.00]
 ```
 
@@ -69,9 +65,73 @@ kesha --lang en audio.ogg                  # warn if detected language differs
 kesha status                               # show installed backend info
 ```
 
-Stdout: transcript. Stderr: errors. Pipe-friendly.
+Multiple files — headers per file, like `head`:
+
+```bash
+$ kesha freedom.ogg tahiti.ogg
+=== freedom.ogg ===
+Свободу попугаям! Свободу!
+
+=== tahiti.ogg ===
+Таити, Таити! Не были мы ни в какой Таити! Нас и тут неплохо кормят.
+```
+
+Stdout: transcript. Stderr: errors. Pipe-friendly. Also available as `parakeet` command (backward-compatible alias).
+
+## Text-to-Speech
+
+Kesha speaks back via Kokoro-82M (English) and Piper (Russian). Voice is auto-picked from the input text's language — `en` routes to Kokoro, `ru` to Piper. Pass `--voice` to override.
+
+```bash
+brew install espeak-ng              # one-time system dep (macOS — apt/choco elsewhere)
+kesha install --tts                 # ~390MB (Kokoro + Piper RU, opt-in)
+kesha say "Hello, world" > hello.wav
+kesha say "Привет, мир" > privet.wav    # auto-routes to ru-denis
+echo "long text" | kesha say > reply.wav
+kesha say --out reply.wav "text"
+kesha say --voice en-af_heart "text"    # explicit voice overrides auto-routing
+kesha say --list-voices
+```
+
+Output format: WAV mono float32 (24 kHz for Kokoro, 22.05 kHz for Piper). OGG/Opus and MP3 are tracked in follow-up issues. Static-linking of `espeak-ng` to remove the system dep is [#124](https://github.com/drakulavich/kesha-voice-kit/issues/124).
+
+**Supported voices:**
+- English: `en-af_heart` (default), plus any Kokoro voice you download into `~/.cache/kesha/models/kokoro-82m/voices/`
+- Russian: `ru-denis` (default). More speakers (dmitri, irina, ruslan) are ready to drop in once needed.
+- macOS system voices (preview — dev builds only, see below): `macos-<identifier-or-language>` routes to `AVSpeechSynthesizer`. Zero install, any of the 180+ voices already on your Mac.
+
+### macOS system voices (preview)
+
+`kesha say --voice macos-*` routes through `AVSpeechSynthesizer` on macOS, so you get voice synthesis for free — no 390 MB TTS bundle, no `espeak-ng` dep. Currently gated behind the `system_tts` cargo feature; release-binary integration is tracked as part of [#141](https://github.com/drakulavich/kesha-voice-kit/issues/141).
+
+```bash
+# From a dev build: `cargo build --release --features system_tts` in rust/.
+kesha say --voice macos-com.apple.voice.compact.en-US.Samantha "Hello from system TTS" > out.wav
+kesha say --voice macos-ru-RU "Привет, мир" > hello-ru.wav   # language-code fallback
+```
+
+Voice id format: `macos-<id>` where `<id>` is either a full Apple identifier (`com.apple.voice.compact.en-US.Samantha`) or a language code (`en-US`, `ru-RU`) — the Swift helper tries the identifier first and falls back to the language. Output is mono float32 @ 22050 Hz, structurally identical to Piper.
+
+Quality tradeoff is honest: macOS system voices are notification-grade. Use them when you want zero-install TTS on macOS; keep Kokoro/Piper for anything that needs to sound good.
+
+### SSML (preview)
+
+`kesha say --ssml` accepts [SSML](https://www.w3.org/TR/speech-synthesis11/) for pauses and text-structuring. v1 is deliberately small:
+
+```bash
+kesha say --ssml '<speak>Hello <break time="500ms"/> world.</speak>'
+kesha say --ssml --voice ru-denis '<speak>Привет <break time="1s"/> мир.</speak>'
+```
+
+| Tag | Status |
+|---|---|
+| `<speak>` | ✅ required root |
+| `<break time="Nms"\|"Ns"\|default>` | ✅ inserts silence of the given duration |
+| plain text inside `<speak>` | ✅ synthesized via the selected engine |
+| `<emphasis>`, `<prosody>`, `<phoneme>`, `<say-as>` | ⚠️ stripped with a stderr warning (contained text still synthesized); tracked in [#122](https://github.com/drakulavich/kesha-voice-kit/issues/122) |
+| `<!DOCTYPE>` | ❌ rejected (hardening against XXE) |
 
-**Also available as `parakeet` command** (backward-compatible alias).
+SSML is opt-in via the explicit `--ssml` flag — inputs that happen to contain `<angle brackets>` aren't misinterpreted as SSML.
 
 ## What's Inside
 
@@ -87,7 +147,7 @@ All models run through `kesha-engine` — a Rust binary using [FluidAudio](https
 
 ## Performance
 
-> **~19x faster than Whisper** on Apple Silicon, **~2.5x faster** on CPU
+> **~15x faster than Whisper** on Apple Silicon (M3 Pro), **~2.5x faster** on CPU
 
 Compared against Whisper `large-v3-turbo` — all engines auto-detect language.
 
@@ -148,4 +208,4 @@ See [CONTRIBUTING.md](CONTRIBUTING.md).
 
 ## License
 
-Made with 💛🩵 Published under MIT License.
+Made with 💛🩵 and 🥤 energy under MIT License

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@drakulavich/kesha-voice-kit",
-  "version": "1.0.10",
+  "version": "1.2.0",
   "description": "Open-source voice toolkit for Apple Silicon. Speech-to-text, language detection. 25 languages.",
   "type": "module",
   "bin": {
@@ -29,7 +29,7 @@
     ]
   },
   "keshaEngine": {
-    "version": "1.0.2"
+    "version": "1.2.0"
   },
   "scripts": {
     "test": "bun test",

package/src/cli.ts

@@ -7,6 +7,7 @@ import { downloadEngine } from "./engine-install";
 import { detectAudioLanguageEngine, detectTextLanguageEngine } from "./engine";
 import type { LangDetectResult } from "./engine";
 import { log } from "./log";
+import { say, SayError } from "./say";
 import { showStatus } from "./status";
 import { suggestCommand } from "./suggest-command";
 
@@ -24,12 +25,14 @@ interface InstallCommandArgs {
   coreml: boolean;
   onnx: boolean;
   "no-cache": boolean;
+  tts: boolean;
 }
 
 interface MainCommandArgs {
   _: string[];
   json: boolean;
   verbose: boolean;
+  debug: boolean;
   format?: string;
   lang?: string;
 }
@@ -46,9 +49,26 @@ function resolveBackendFlag(coreml: boolean, onnx: boolean): string | undefined
   return undefined;
 }
 
-async function performInstall(noCache: boolean, backend?: string) {
+async function askForStar() {
+  const gh = Bun.which("gh");
+  if (!gh) {
+    log.info("\nIf you enjoy Kesha Voice Kit, consider starring the repo:");
+    log.info("  https://github.com/drakulavich/kesha-voice-kit");
+    return;
+  }
+  const authCheck = Bun.spawnSync([gh, "auth", "status"], { stdout: "ignore", stderr: "ignore" });
+  if (authCheck.exitCode !== 0) return;
+  const starred = Bun.spawnSync([gh, "api", "user/starred/drakulavich/kesha-voice-kit"], { stdout: "ignore", stderr: "ignore" });
+  if (starred.exitCode === 0) return; // already starred
+  log.info("\n⭐ If you enjoy Kesha Voice Kit, star it on GitHub:");
+  log.info("  https://github.com/drakulavich/kesha-voice-kit");
+  log.info('  Or run: gh api -X PUT /user/starred/drakulavich/kesha-voice-kit');
+}
+
+async function performInstall(noCache: boolean, backend?: string, tts = false) {
   try {
-    await downloadEngine(noCache, backend);
+    await downloadEngine(noCache, backend, { tts });
+    await askForStar();
   } catch (err: unknown) {
     const message = err instanceof Error ? err.message : String(err);
     log.error(message);
@@ -77,13 +97,134 @@ export const installCommand = defineCommand({
       description: "Re-download even if cached",
       default: false,
     },
+    tts: {
+      type: "boolean",
+      description: "Also install TTS models (Kokoro EN + Piper RU, ~390MB, requires espeak-ng on PATH)",
+      default: false,
+    },
   },
   async run({ args }: { args: InstallCommandArgs }) {
     const backend = resolveBackendFlag(args.coreml, args.onnx);
-    await performInstall(args["no-cache"], backend);
+    await performInstall(args["no-cache"], backend, args.tts);
   },
 });
 
+export const sayCommand = defineCommand({
+  meta: {
+    name: "say",
+    description: "Synthesize speech from text (TTS). Writes WAV to stdout (or --out file).",
+  },
+  args: {
+    text: { type: "positional", required: false, description: "Text to speak (stdin if omitted)" },
+    voice: { type: "string", description: "Voice id, e.g. en-af_heart" },
+    lang: { type: "string", description: "espeak language code (default en-us)" },
+    out: { type: "string", description: "Write WAV to file instead of stdout" },
+    rate: { type: "string", description: "Speaking rate 0.5–2.0", default: "1.0" },
+    "list-voices": { type: "boolean", description: "List installed voices and exit" },
+    ssml: {
+      type: "boolean",
+      description: "Parse input as SSML (supports <speak>, <break>; strips unknown tags)",
+    },
+    verbose: {
+      type: "boolean",
+      description: "Log TTS synthesis time to stderr",
+      default: false,
+    },
+    debug: {
+      type: "boolean",
+      description: "Trace engine subprocess calls on stderr (or KESHA_DEBUG=1)",
+      default: false,
+    },
+  },
+  async run({ args }) {
+    if (args.debug) log.debugEnabled = true;
+    if (args["list-voices"]) {
+      // The engine prints the list directly — just relay its stdout + exit code.
+      const { getEngineBinPath } = await import("./engine");
+      const proc = Bun.spawn([getEngineBinPath(), "say", "--list-voices"], {
+        stdout: "inherit",
+        stderr: "inherit",
+      });
+      process.exit(await proc.exited);
+    }
+
+    const inlineText = typeof args.text === "string" ? args.text : undefined;
+    const text = await resolveText(inlineText);
+    const explicitVoice = typeof args.voice === "string" ? args.voice : undefined;
+    const voice = explicitVoice ?? (await autoRouteVoice(text));
+
+    const opts = {
+      text,
+      voice,
+      lang: typeof args.lang === "string" ? args.lang : undefined,
+      out: typeof args.out === "string" ? args.out : undefined,
+      rate: args.rate ? Number(args.rate) : undefined,
+      ssml: Boolean(args.ssml),
+    };
+
+    try {
+      const startedAt = performance.now();
+      const wav = await say(opts);
+      const ttsTimeMs = Math.round(performance.now() - startedAt);
+      if (args.verbose) {
+        // stderr — stdout may carry raw WAV bytes when --out is omitted.
+        console.error(`TTS time: ${ttsTimeMs}ms`);
+      }
+      if (!opts.out) {
+        process.stdout.write(wav);
+      }
+    } catch (err) {
+      if (err instanceof SayError) {
+        log.error(err.stderr.trim() || err.message);
+        process.exit(err.exitCode);
+      }
+      const message = err instanceof Error ? err.message : String(err);
+      log.error(message);
+      process.exit(4);
+    }
+  },
+});
+
+/** Resolve the text to synthesize: inline positional, else read from stdin. */
+async function resolveText(inline: string | undefined): Promise<string> {
+  if (inline !== undefined && inline.length > 0) return inline;
+  const chunks: Uint8Array[] = [];
+  for await (const chunk of Bun.stdin.stream()) {
+    chunks.push(chunk);
+  }
+  const total = chunks.reduce((n, c) => n + c.byteLength, 0);
+  const merged = new Uint8Array(total);
+  let offset = 0;
+  for (const c of chunks) {
+    merged.set(c, offset);
+    offset += c.byteLength;
+  }
+  return new TextDecoder().decode(merged).trim();
+}
+
+/** Map a detected language code to a default voice id. Unknown / low-confidence → undefined. */
+export function pickVoiceForLang(
+  code: string | undefined,
+  confidence: number,
+): string | undefined {
+  if (!code || confidence < 0.5) return undefined;
+  switch (code) {
+    case "en":
+      return "en-af_heart";
+    case "ru":
+      return "ru-denis";
+    default:
+      return undefined;
+  }
+}
+
+/** Run NLLanguageRecognizer (via engine) on the text and pick a default voice. */
+async function autoRouteVoice(text: string): Promise<string | undefined> {
+  if (!text) return undefined;
+  const detected = await detectTextLanguageEngine(text);
+  return pickVoiceForLang(detected?.code, detected?.confidence ?? 0);
+}
+
 export const statusCommand = defineCommand({
   meta: {
     name: "status",
@@ -122,8 +263,14 @@ export const mainCommand = defineCommand({
       type: "string",
       description: "Expected language code (ISO 639-1), warn if mismatch",
     },
+    debug: {
+      type: "boolean",
+      description: "Trace engine subprocess calls on stderr (or KESHA_DEBUG=1)",
+      default: false,
+    },
   },
   async run({ args }: { args: MainCommandArgs }) {
+    if (args.debug) log.debugEnabled = true;
     const files = args._;
 
     if (files.length === 0) {
@@ -137,6 +284,7 @@ export const mainCommand = defineCommand({
     const wantsLangId = !!(args.lang || args.verbose || args.json || args.format === "transcript" || args.format === "json");
 
     for (const file of files) {
+      const startedAt = performance.now();
       try {
         // Run audio lang-id and transcription concurrently
         const [audioResult, text] = await Promise.all([
@@ -175,6 +323,7 @@ export const mainCommand = defineCommand({
           lang,
           audioLanguage,
           textLanguage: textLanguage ?? (tinyldLang ? { code: tinyldLang, confidence: 0 } : undefined),
+          sttTimeMs: Math.round(performance.now() - startedAt),
         });
       } catch (err: unknown) {
         hasError = true;
@@ -197,7 +346,7 @@ export const mainCommand = defineCommand({
   },
 });
 
-const SUBCOMMANDS = ["install", "status"];
+const SUBCOMMANDS = ["install", "status", "say"];
 
 export async function runCli(rawArgs = process.argv.slice(2)): Promise<void> {
   const [firstArg, ...restArgs] = rawArgs;
@@ -212,6 +361,11 @@ export async function runCli(rawArgs = process.argv.slice(2)): Promise<void> {
     return;
   }
 
+  if (firstArg === "say") {
+    await runMain(sayCommand, { rawArgs: restArgs });
+    return;
+  }
+
   // Check for unknown subcommands (non-flag, non-file-path args)
   if (firstArg && !firstArg.startsWith("-") && !firstArg.includes(".") && !firstArg.includes("/")) {
     const suggestion = suggestCommand(firstArg, SUBCOMMANDS);
@@ -231,6 +385,8 @@ export type TranscribeResult = {
   lang: string;
   audioLanguage?: LangDetectResult;
   textLanguage?: LangDetectResult;
+  /** Wall-clock time around the engine subprocess calls for this file, ms. See #139. */
+  sttTimeMs?: number;
 };
 
 export function formatTextOutput(results: TranscribeResult[]): string {
@@ -258,6 +414,9 @@ export function formatVerboseOutput(results: TranscribeResult[]): string {
         const confStr = textLang.confidence > 0 ? ` (confidence: ${textLang.confidence.toFixed(2)})` : "";
         lines.push(`Text language: ${textLang.code}${confStr}`);
       }
+      if (r.sttTimeMs !== undefined) {
+        lines.push(`STT time: ${r.sttTimeMs}ms`);
+      }
       lines.push("---");
       lines.push(r.text);
       return lines.join("\n");

package/src/engine-install.ts

@@ -17,7 +17,16 @@ function getEngineBinaryName(): string {
   throw new Error(`Unsupported platform: ${platform} ${arch}`);
 }
 
-export async function downloadEngine(noCache = false, backend?: string): Promise<string> {
+export interface InstallOptions {
+  /** Also install Kokoro TTS models. Requires espeak-ng on PATH. */
+  tts?: boolean;
+}
+
+export async function downloadEngine(
+  noCache = false,
+  backend?: string,
+  options: InstallOptions = {},
+): Promise<string> {
   const binPath = getEngineBinPath();
 
   if (!noCache && existsSync(binPath)) {
@@ -68,7 +77,11 @@ export async function downloadEngine(noCache = false, backend?: string): Promise
   }
 
   log.progress("Installing models...");
-  const installArgs = ["install", ...(noCache ? ["--no-cache"] : [])];
+  const installArgs = [
+    "install",
+    ...(noCache ? ["--no-cache"] : []),
+    ...(options.tts ? ["--tts"] : []),
+  ];
   const proc = Bun.spawnSync([binPath, ...installArgs], {
     stdout: "pipe",
     stderr: "pipe",

package/src/engine.ts

@@ -1,16 +1,22 @@
 import { join } from "path";
 import { homedir } from "os";
 import { existsSync } from "fs";
+import { log } from "./log";
 
 export interface LangDetectResult {
   code: string;
   confidence: number;
 }
 
-const ENGINE_BIN_PATH = join(homedir(), ".cache", "kesha", "engine", "bin", "kesha-engine");
+const DEFAULT_ENGINE_BIN_PATH = join(homedir(), ".cache", "kesha", "engine", "bin", "kesha-engine");
 
+/**
+ * Path to the `kesha-engine` binary. Defaults to the install location under
+ * `~/.cache/kesha/engine/bin/`. The `KESHA_ENGINE_BIN` env var overrides — useful
+ * for running against a freshly-built engine during development or in e2e tests.
+ */
 export function getEngineBinPath(): string {
-  return ENGINE_BIN_PATH;
+  return process.env.KESHA_ENGINE_BIN ?? DEFAULT_ENGINE_BIN_PATH;
 }
 
 export function isEngineInstalled(): boolean {
@@ -19,6 +25,8 @@ export function isEngineInstalled(): boolean {
 
 async function runEngine(args: string[]): Promise<{ stdout: string; stderr: string; exitCode: number }> {
   const binPath = getEngineBinPath();
+  const startedAt = performance.now();
+  log.debug(`spawn ${binPath} ${args.join(" ")}`);
   const proc = Bun.spawn([binPath, ...args], {
     stdout: "pipe",
     stderr: "pipe",
@@ -30,6 +38,7 @@ async function runEngine(args: string[]): Promise<{ stdout: string; stderr: stri
     proc.exited,
   ]);
 
+  log.debug(`exit=${exitCode} dt=${Math.round(performance.now() - startedAt)}ms args=${JSON.stringify(args)}`);
   return { stdout: stdout.trim(), stderr: stderr.trim(), exitCode };
 }
 

package/src/lib.ts

@@ -4,6 +4,12 @@ import { downloadEngine } from "./engine-install";
 
 export type { TranscribeOptions };
 export { downloadEngine as downloadModel };
+export { say, type SayOptions, SayError } from "./say";
+
+/** Install Kokoro TTS models. Shorthand for `downloadModel({ tts: true })`. */
+export async function downloadTts(noCache = false): Promise<void> {
+  await downloadEngine(noCache, undefined, { tts: true });
+}
 
 /** @deprecated Use `downloadModel` instead. */
 export const downloadCoreML = downloadEngine;

package/src/log.ts

@@ -1,9 +1,26 @@
 import pc from "picocolors";
 
+/**
+ * Debug mode (#148): when `KESHA_DEBUG` is truthy OR the caller has flipped
+ * `log.debugEnabled = true` (via `--debug`), `log.debug()` writes structured
+ * trace lines to stderr. Otherwise it's a no-op. Stdout is never touched.
+ */
+function envDebug(): boolean {
+  const v = process.env.KESHA_DEBUG;
+  return !!v && v !== "0" && v.toLowerCase() !== "false";
+}
+
 export const log = {
   info: (msg: string) => console.log(msg),
   success: (msg: string) => console.log(pc.green(msg)),
   progress: (msg: string) => console.log(pc.cyan(msg)),
   warn: (msg: string) => console.error(pc.yellow(msg)),
   error: (msg: string) => console.error(pc.red(msg)),
+
+  debugEnabled: false,
+  debug(msg: string): void {
+    if (this.debugEnabled || envDebug()) {
+      console.error(pc.dim(`[debug] ${msg}`));
+    }
+  },
 };

package/src/say.ts

@@ -0,0 +1,89 @@
+import { getEngineBinPath, isEngineInstalled } from "./engine";
+import { log } from "./log";
+
+export interface SayOptions {
+  /**
+   * Text to synthesize. Required for programmatic callers — `say()` does not
+   * forward the host process's stdin. The CLI (`kesha say` with no positional
+   * arg) handles stdin separately before invoking `say()`.
+   */
+  text?: string;
+  /** Voice id, e.g. `en-af_heart`. Defaults to engine default. */
+  voice?: string;
+  /** Override the voice's default espeak language code. */
+  lang?: string;
+  /** Write audio to this path instead of returning bytes. */
+  out?: string;
+  /** Speaking rate 0.5–2.0. */
+  rate?: number;
+  /** Parse `text` as SSML (`<speak>…<break time="500ms"/>…</speak>`). See issue #122. */
+  ssml?: boolean;
+}
+
+/** Build the argv passed to `kesha-engine say` (pure, unit-testable). */
+export function buildSayArgs(o: SayOptions): string[] {
+  const args: string[] = ["say"];
+  if (o.voice) args.push("--voice", o.voice);
+  if (o.lang) args.push("--lang", o.lang);
+  if (o.out) args.push("--out", o.out);
+  if (o.rate !== undefined && o.rate !== 1.0) args.push("--rate", String(o.rate));
+  if (o.ssml) args.push("--ssml");
+  if (o.text !== undefined && o.text.length > 0) args.push(o.text);
+  return args;
+}
+
+export class SayError extends Error {
+  constructor(
+    message: string,
+    public readonly exitCode: number,
+    public readonly stderr: string,
+  ) {
+    super(message);
+    this.name = "SayError";
+  }
+}
+
+/**
+ * Synthesize speech. Returns raw WAV bytes. If `out` is provided in options,
+ * the engine writes to the file and this function returns an empty buffer.
+ */
+export async function say(opts: SayOptions): Promise<Uint8Array> {
+  if (!isEngineInstalled()) {
+    throw new SayError(
+      "kesha-engine not installed. run: kesha install",
+      1,
+      "",
+    );
+  }
+  const args = buildSayArgs({ ...opts, text: undefined });
+  const startedAt = performance.now();
+  log.debug(`spawn ${getEngineBinPath()} ${args.join(" ")} (text: ${opts.text?.length ?? 0} chars)`);
+  const proc = Bun.spawn([getEngineBinPath(), ...args], {
+    stdin: "pipe",
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+
+  if (opts.text !== undefined && opts.text.length > 0) {
+    proc.stdin.write(opts.text);
+    await proc.stdin.end();
+  } else {
+    await proc.stdin.end();
+  }
+
+  const [stdoutBuf, stderrText, exitCode] = await Promise.all([
+    new Response(proc.stdout).arrayBuffer(),
+    new Response(proc.stderr).text(),
+    proc.exited,
+  ]);
+
+  log.debug(`exit=${exitCode} dt=${Math.round(performance.now() - startedAt)}ms bytes=${stdoutBuf.byteLength}`);
+  if (exitCode !== 0) {
+    throw new SayError(
+      stderrText.trim() || `kesha-engine say exited ${exitCode}`,
+      exitCode,
+      stderrText,
+    );
+  }
+  return new Uint8Array(stdoutBuf);
+}

package/src/status.ts

@@ -1,3 +1,6 @@
+import { readdirSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
 import { isEngineInstalled, getEngineBinPath, getEngineCapabilities } from "./engine";
 import { log } from "./log";
 import pc from "picocolors";
@@ -37,7 +40,48 @@ export async function showStatus(): Promise<void> {
   log.info(formatStatusLine("Platform", `${process.platform} ${process.arch}`, true));
   log.info("");
 
+  if (installed) {
+    const voices = listInstalledVoices();
+    if (voices.length > 0) {
+      log.info("TTS voices:");
+      for (const v of voices) {
+        log.info(`  ${v}`);
+      }
+      log.info("");
+    }
+  }
+
   if (!installed) {
     log.warn('Run "kesha install" to download the engine and models.');
   }
 }
+
+function kesheCacheDir(): string {
+  return process.env.KESHA_CACHE_DIR ?? join(homedir(), ".cache", "kesha");
+}
+
+function listInstalledVoices(): string[] {
+  const cache = kesheCacheDir();
+  const voices: string[] = [];
+  try {
+    const kokoro = readdirSync(join(cache, "models", "kokoro-82m", "voices"));
+    for (const f of kokoro) {
+      if (f.endsWith(".bin")) voices.push(`en-${f.replace(/\.bin$/, "")}`);
+    }
+  } catch {
+    /* Kokoro not installed */
+  }
+  try {
+    // Piper RU files follow `ru_RU-<name>-<quality>.onnx` — report just `<name>`.
+    const piper = readdirSync(join(cache, "models", "piper-ru"));
+    for (const f of piper) {
+      if (!f.endsWith(".onnx")) continue;
+      const stem = f.replace(/\.onnx$/, "");
+      const name = stem.replace(/^ru_RU-/, "").split("-")[0];
+      if (name) voices.push(`ru-${name}`);
+    }
+  } catch {
+    /* Piper not installed */
+  }
+  return voices.sort();
+}