@drakulavich/kesha-voice-kit 1.24.2 → 1.24.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@drakulavich/kesha-voice-kit",
-  "version": "1.24.2",
+  "version": "1.24.4",
   "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": {
@@ -38,7 +38,7 @@
     }
   },
   "keshaEngine": {
-    "version": "1.24.2"
+    "version": "1.24.4"
   },
   "scripts": {
     "test": "bun test",
@@ -99,5 +99,8 @@
     "picocolors": "^1.1.1",
     "tinyld": "^1.3.4",
     "zod": "^4.4.3"
+  },
+  "overrides": {
+    "hono": "^4.12.25"
   }
 }

package/src/cli/dispatch.ts

@@ -46,9 +46,7 @@ function isFalsey(v: string): boolean {
   return FALSEY_VALUES.has(v.trim().toLowerCase());
 }
 
-// Whether the process was launched with NO_COLOR already forced on. Captured
-// once at import (before any runCli) so re-enabling colors never clobbers an
-// externally-set NO_COLOR — we only clear the var on re-enable when WE set it.
+// Captured at import so re-enabling colors never clobbers a user-exported NO_COLOR.
 const USER_FORCED_NO_COLOR =
   process.env.NO_COLOR !== undefined && !isFalsey(process.env.NO_COLOR);
 
@@ -105,47 +103,72 @@ export function resolveQuietMode(rawArgs: string[]): { quiet: boolean; rawArgs:
   return { quiet: value, rawArgs: cleaned };
 }
 
-export async function runCli(rawArgs = process.argv.slice(2)): Promise<void> {
-  // Global flags resolved before citty so they apply to every command (and help
-  // output) and never reach a subcommand's arg schema.
-  const color = resolveColorMode(rawArgs);
-  // Reset on EVERY invocation (not just the disable path): an earlier
-  // --no-color / CI call must not leave colors permanently off for later
-  // in-process calls (unit tests, `kesha mcp`). picocolors already honors
-  // NO_COLOR at startup; setting the env var also propagates to the engine.
-  setColorEnabled(!color.disableColor);
-  // Keep NO_COLOR symmetric so it doesn't leak to engine subprocesses spawned
-  // by a later in-process call: set it when WE disable, clear it on re-enable —
-  // but never clear a NO_COLOR the user exported themselves.
-  if (color.disableColor) {
+/**
+ * Sync NO_COLOR with the resolved color decision so engine subprocesses inherit
+ * the right value. Separated from setColorEnabled so it can be tested without
+ * picocolors side-effects.
+ *
+ * Never clears a NO_COLOR the user exported before this process started
+ * (USER_FORCED_NO_COLOR guard).
+ */
+export function applyColorEnv(disableColor: boolean): void {
+  if (disableColor) {
     process.env.NO_COLOR = "1";
   } else if (!USER_FORCED_NO_COLOR) {
     delete process.env.NO_COLOR;
   }
+}
+
+/**
+ * Classify the first positional arg for routing.
+ *
+ * - `"subcommand"` — exact match in the known subcommand set
+ * - `"unknown"`    — bare token that looks like a typo (not a flag, not path-like)
+ * - `"main"`       — flags, path-like args, or no arg (→ transcribe / help)
+ */
+export function classifyFirstArg(
+  firstArg: string | undefined,
+  subcommandKeys: string[],
+): "subcommand" | "unknown" | "main" {
+  if (!firstArg) return "main";
+  if (subcommandKeys.includes(firstArg)) return "subcommand";
+  // Flags and path-like tokens fall through to the main transcribe command.
+  if (firstArg.startsWith("-") || isPathLike(firstArg)) return "main";
+  return "unknown";
+}
+
+export async function runCli(rawArgs = process.argv.slice(2)): Promise<void> {
+  // Global flags resolved before citty so they apply to every command and never reach a subcommand's arg schema.
+  const color = resolveColorMode(rawArgs);
+  // Reset on every invocation so an earlier --no-color/CI call doesn't leave colors off for later in-process calls (unit tests, `kesha mcp`).
+  setColorEnabled(!color.disableColor);
+  applyColorEnv(color.disableColor);
 
   const quiet = resolveQuietMode(color.rawArgs);
   log.quietEnabled = quiet.quiet;
 
   rawArgs = quiet.rawArgs;
   const [firstArg, ...restArgs] = rawArgs;
+  const subcommandKeys = Object.keys(SUBCOMMANDS);
 
-  if (firstArg && Object.hasOwn(SUBCOMMANDS, firstArg)) {
-    await runMain(SUBCOMMANDS[firstArg], { rawArgs: restArgs });
-    return;
-  }
+  switch (classifyFirstArg(firstArg, subcommandKeys)) {
+    case "subcommand":
+      await runMain(SUBCOMMANDS[firstArg!], { rawArgs: restArgs });
+      return;
 
-  // Check for unknown subcommands (non-flag, non-file-path args).
-  // Extensionless existing files remain valid transcription inputs; missing
-  // bare tokens are more likely command typos and should not start the engine.
-  if (firstArg && !firstArg.startsWith("-") && !isPathLike(firstArg)) {
-    const suggestion = suggestCommand(firstArg, Object.keys(SUBCOMMANDS));
-    log.error(`unknown command '${firstArg}'`);
-    if (suggestion && suggestion !== firstArg) {
-      log.warn(`(Did you mean ${suggestion}?)`);
+    case "unknown": {
+      // Extensionless existing files are valid transcription inputs; bare non-path tokens are likely command typos.
+      const suggestion = suggestCommand(firstArg!, subcommandKeys);
+      log.error(`unknown command '${firstArg}'`);
+      if (suggestion && suggestion !== firstArg) {
+        log.warn(`(Did you mean ${suggestion}?)`);
+      }
+      log.warn(`If this is an audio file, pass a path like './${firstArg}'.`);
+      process.exit(1);
+      break;
     }
-    log.warn(`If this is an audio file, pass a path like './${firstArg}'.`);
-    process.exit(1);
-  }
 
-  await runMain(mainCommand, { rawArgs });
+    default:
+      await runMain(mainCommand, { rawArgs });
+  }
 }

package/src/cli/init.ts

@@ -5,12 +5,8 @@ import { multiselect, isCancel, cancel } from "@clack/prompts";
 import { renderInstallPlan } from "../install-plan";
 import { log } from "../log";
 import { getEngineCapabilities } from "../engine";
-import {
-  performInstall,
-  resolveBackendFlag,
-  resolveNoCacheFlag,
-  TTS_LANG_FALLBACK,
-} from "./install";
+import { performInstall, resolveBackendFlag, resolveNoCacheFlag, TTS_LANG_FALLBACK } from "./install";
+import type { SharedInstallArgs } from "./types";
 
 const TTS_LANG_LABELS: Record<string, string> = {
   en: "English (Kokoro)",
@@ -44,16 +40,7 @@ async function promptTtsLangs(preselect: string[]): Promise<string[]> {
   return selected as string[];
 }
 
-export interface InitCommandArgs {
-  coreml: boolean;
-  onnx: boolean;
-  "no-cache": boolean;
-  noCache?: boolean;
-  no_cache?: boolean;
-  tts: boolean;
-  vad: boolean;
-  diarize: boolean;
-  plan: boolean;
+export interface InitCommandArgs extends SharedInstallArgs {
   yes: boolean;
 }
 

package/src/cli/install.ts

@@ -7,19 +7,11 @@ import { maybeAskForStar } from "../star";
 import { log } from "../log";
 import { packageVersion } from "../package-info";
 import { createDiagnosticLogSession, type DiagnosticLogSession } from "../diagnostic-log";
+import type { SharedInstallArgs } from "./types";
 
-export interface InstallCommandArgs {
+export interface InstallCommandArgs extends SharedInstallArgs {
   /** Positional args after `install` — candidate TTS language codes. */
   _?: string[];
-  coreml: boolean;
-  onnx: boolean;
-  "no-cache": boolean;
-  noCache?: boolean;
-  no_cache?: boolean;
-  tts: boolean;
-  vad: boolean;
-  diarize: boolean;
-  plan: boolean;
 }
 
 /**
@@ -30,9 +22,7 @@ export interface InstallCommandArgs {
 export const TTS_LANG_FALLBACK = ["en", "es", "fr", "it", "pt", "ru"];
 
 export interface TtsArgInput {
-  /** Whether --tts was passed. */
   tts: boolean;
-  /** Positional args after the install command (candidate language codes). */
   positionals: string[];
 }