whisper-api 0.1.0

package/dist/whisper-api.js

@@ -0,0 +1,1125 @@
+// src/cli/index.ts
+import fs9 from "fs";
+import path7 from "path";
+import dotenv from "dotenv";
+import { Command } from "commander";
+import { intro, outro, select, multiselect, isCancel, cancel, note } from "@clack/prompts";
+
+// src/config/index.ts
+import os from "os";
+import path from "path";
+import fs from "fs";
+import fsp from "fs/promises";
+var DEFAULT_CONFIG = {
+  engine: "auto",
+  defaultModel: "base.en",
+  host: "0.0.0.0",
+  port: 8080,
+  maxUploadBytes: 25 * 1024 * 1024,
+  rateLimit: { max: 120, timeWindow: "1 minute" }
+};
+function homeDir() {
+  return process.env.WHISPER_API_HOME || path.join(os.homedir(), ".whisper-api");
+}
+var paths = {
+  home: homeDir,
+  config: () => path.join(homeDir(), "config.json"),
+  keys: () => path.join(homeDir(), "keys.json"),
+  /** GGML model files for whisper.cpp. */
+  models: () => path.join(homeDir(), "models"),
+  /** transformers.js / ONNX model cache. */
+  cache: () => path.join(homeDir(), "cache"),
+  /** Built/downloaded whisper.cpp binaries. */
+  bin: () => path.join(homeDir(), "bin"),
+  /** Scratch space for uploads and converted audio. */
+  tmp: () => path.join(homeDir(), "tmp")
+};
+function ensureDirs() {
+  for (const p of [homeDir(), paths.models(), paths.cache(), paths.bin(), paths.tmp()]) {
+    fs.mkdirSync(p, { recursive: true });
+  }
+}
+async function loadConfig() {
+  try {
+    const raw = await fsp.readFile(paths.config(), "utf8");
+    const parsed = JSON.parse(raw);
+    return {
+      ...DEFAULT_CONFIG,
+      ...parsed,
+      rateLimit: { ...DEFAULT_CONFIG.rateLimit, ...parsed.rateLimit ?? {} }
+    };
+  } catch {
+    return { ...DEFAULT_CONFIG };
+  }
+}
+async function saveConfig(cfg) {
+  ensureDirs();
+  await fsp.writeFile(paths.config(), JSON.stringify(cfg, null, 2) + "\n", "utf8");
+}
+function applyEnvOverrides(cfg) {
+  const out = { ...cfg, rateLimit: { ...cfg.rateLimit } };
+  if (process.env.WHISPER_API_PORT) out.port = Number(process.env.WHISPER_API_PORT);
+  if (process.env.WHISPER_API_HOST) out.host = process.env.WHISPER_API_HOST;
+  if (process.env.WHISPER_API_ENGINE) out.engine = process.env.WHISPER_API_ENGINE;
+  if (process.env.WHISPER_API_MODEL) out.defaultModel = process.env.WHISPER_API_MODEL;
+  if (process.env.WHISPER_API_MAX_UPLOAD_MB) {
+    out.maxUploadBytes = Number(process.env.WHISPER_API_MAX_UPLOAD_MB) * 1024 * 1024;
+  }
+  if (process.env.WHISPER_API_RATE_MAX) out.rateLimit.max = Number(process.env.WHISPER_API_RATE_MAX);
+  return out;
+}
+
+// src/models/registry.ts
+import fs2 from "fs";
+import path2 from "path";
+var HF_GGML_BASE = "https://huggingface.co/ggerganov/whisper.cpp/resolve/main";
+function ggml(name) {
+  return `ggml-${name}.bin`;
+}
+var MODELS = [
+  { name: "tiny.en", ggmlFile: ggml("tiny.en"), onnxRepo: "Xenova/whisper-tiny.en", sizeMB: 75, englishOnly: true, description: "Fastest, English-only" },
+  { name: "tiny", ggmlFile: ggml("tiny"), onnxRepo: "Xenova/whisper-tiny", sizeMB: 75, englishOnly: false, description: "Fastest, multilingual" },
+  { name: "base.en", ggmlFile: ggml("base.en"), onnxRepo: "Xenova/whisper-base.en", sizeMB: 142, englishOnly: true, description: "Good speed/quality, English-only" },
+  { name: "base", ggmlFile: ggml("base"), onnxRepo: "Xenova/whisper-base", sizeMB: 142, englishOnly: false, description: "Good speed/quality, multilingual" },
+  { name: "small.en", ggmlFile: ggml("small.en"), onnxRepo: "Xenova/whisper-small.en", sizeMB: 466, englishOnly: true, description: "Higher quality, English-only" },
+  { name: "small", ggmlFile: ggml("small"), onnxRepo: "Xenova/whisper-small", sizeMB: 466, englishOnly: false, description: "Higher quality, multilingual" },
+  { name: "medium.en", ggmlFile: ggml("medium.en"), onnxRepo: "Xenova/whisper-medium.en", sizeMB: 1500, englishOnly: true, description: "High quality, English-only" },
+  { name: "medium", ggmlFile: ggml("medium"), onnxRepo: "Xenova/whisper-medium", sizeMB: 1500, englishOnly: false, description: "High quality, multilingual" },
+  { name: "large-v3-turbo", ggmlFile: ggml("large-v3-turbo"), onnxRepo: "onnx-community/whisper-large-v3-turbo", sizeMB: 1600, englishOnly: false, description: "Near large-v3 quality, much faster" },
+  { name: "large-v3", ggmlFile: ggml("large-v3"), onnxRepo: "onnx-community/whisper-large-v3", sizeMB: 3100, englishOnly: false, description: "Best quality, multilingual" }
+];
+var OPENAI_ALIASES = /* @__PURE__ */ new Set(["whisper-1", "whisper-large-v3", "gpt-4o-transcribe", "gpt-4o-mini-transcribe"]);
+function isAlias(model) {
+  return OPENAI_ALIASES.has(model);
+}
+function findModel(name) {
+  return MODELS.find((m) => m.name === name);
+}
+function resolveModel(requested, defaultModel) {
+  if (requested && !isAlias(requested)) {
+    const found = findModel(requested);
+    if (found) return found;
+  }
+  return findModel(defaultModel) ?? MODELS.find((m) => m.name === "base.en");
+}
+function ggmlPath(model) {
+  return path2.join(paths.models(), model.ggmlFile);
+}
+function ggmlUrl(model) {
+  return `${HF_GGML_BASE}/${model.ggmlFile}`;
+}
+function isGgmlInstalled(model) {
+  return fs2.existsSync(ggmlPath(model));
+}
+async function downloadGgml(model, onProgress) {
+  const dest = ggmlPath(model);
+  if (fs2.existsSync(dest)) return dest;
+  fs2.mkdirSync(paths.models(), { recursive: true });
+  const url = ggmlUrl(model);
+  const res = await fetch(url, { redirect: "follow" });
+  if (!res.ok || !res.body) {
+    throw new Error(`Failed to download ${model.name} (${res.status} ${res.statusText}) from ${url}`);
+  }
+  const total = Number(res.headers.get("content-length") || 0);
+  const tmp = dest + ".part";
+  const out = fs2.createWriteStream(tmp);
+  let received = 0;
+  const reader = res.body.getReader();
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (value) {
+        received += value.length;
+        if (!out.write(value)) {
+          await new Promise((resolve) => out.once("drain", resolve));
+        }
+        onProgress?.(received, total);
+      }
+    }
+  } finally {
+    out.end();
+    await new Promise((resolve, reject) => {
+      out.on("finish", () => resolve());
+      out.on("error", reject);
+    });
+  }
+  fs2.renameSync(tmp, dest);
+  return dest;
+}
+
+// src/keys/store.ts
+import crypto from "crypto";
+import fs3 from "fs";
+import fsp2 from "fs/promises";
+var KEY_PREFIX = "sk-wapi-";
+function generateRawKey() {
+  return KEY_PREFIX + crypto.randomBytes(32).toString("base64url");
+}
+function hashKey(raw) {
+  return crypto.createHash("sha256").update(raw).digest("hex");
+}
+function newId() {
+  return "key_" + crypto.randomBytes(10).toString("hex");
+}
+async function load() {
+  try {
+    const raw = await fsp2.readFile(paths.keys(), "utf8");
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+async function persist(list) {
+  ensureDirs();
+  await fsp2.writeFile(paths.keys(), JSON.stringify(list, null, 2) + "\n", { encoding: "utf8", mode: 384 });
+  try {
+    fs3.chmodSync(paths.keys(), 384);
+  } catch {
+  }
+}
+async function createKey(name) {
+  const raw = generateRawKey();
+  const record = {
+    id: newId(),
+    name: name || "default",
+    prefix: raw.slice(0, KEY_PREFIX.length + 6),
+    hash: hashKey(raw),
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    lastUsedAt: null,
+    revoked: false
+  };
+  const list = await load();
+  list.push(record);
+  await persist(list);
+  return { raw, record };
+}
+async function listKeys() {
+  return load();
+}
+async function countActiveKeys() {
+  return (await load()).filter((k) => !k.revoked).length;
+}
+async function revokeKey(idOrPrefix) {
+  const list = await load();
+  let changed = false;
+  for (const rec of list) {
+    if (!rec.revoked && (rec.id === idOrPrefix || rec.prefix === idOrPrefix)) {
+      rec.revoked = true;
+      changed = true;
+    }
+  }
+  if (changed) await persist(list);
+  return changed;
+}
+async function verifyKey(raw) {
+  if (!raw || !raw.startsWith(KEY_PREFIX)) return null;
+  const candidate = Buffer.from(hashKey(raw), "hex");
+  const list = await load();
+  let match = null;
+  for (const rec of list) {
+    if (rec.revoked) continue;
+    const stored = Buffer.from(rec.hash, "hex");
+    if (stored.length === candidate.length && crypto.timingSafeEqual(stored, candidate)) {
+      match = rec;
+      break;
+    }
+  }
+  if (match) {
+    match.lastUsedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await persist(list);
+  }
+  return match;
+}
+
+// src/audio.ts
+import { spawn } from "child_process";
+import fs4 from "fs";
+import path3 from "path";
+import crypto2 from "crypto";
+import ffmpegStatic from "ffmpeg-static";
+var SAMPLE_RATE = 16e3;
+function ffmpegBin() {
+  return process.env.FFMPEG_PATH || ffmpegStatic || "ffmpeg";
+}
+function run(args) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn(ffmpegBin(), args, { stdio: ["ignore", "pipe", "pipe"] });
+    const out = [];
+    const err = [];
+    proc.stdout.on("data", (d) => out.push(d));
+    proc.stderr.on("data", (d) => err.push(d));
+    proc.on("error", reject);
+    proc.on("close", (code) => {
+      if (code === 0) resolve(Buffer.concat(out));
+      else reject(new Error(`ffmpeg exited with code ${code}: ${Buffer.concat(err).toString("utf8").slice(-800)}`));
+    });
+  });
+}
+async function toWav16k(inputPath) {
+  ensureDirs();
+  const outPath = path3.join(paths.tmp(), `wav-${crypto2.randomBytes(8).toString("hex")}.wav`);
+  await run(["-nostdin", "-i", inputPath, "-ar", String(SAMPLE_RATE), "-ac", "1", "-c:a", "pcm_s16le", "-f", "wav", outPath, "-y"]);
+  return outPath;
+}
+async function toFloat32(inputPath) {
+  const raw = await run(["-nostdin", "-i", inputPath, "-ar", String(SAMPLE_RATE), "-ac", "1", "-f", "f32le", "-"]);
+  const aligned = new Uint8Array(raw.byteLength);
+  aligned.set(raw);
+  const samples = new Float32Array(aligned.buffer, 0, Math.floor(aligned.byteLength / 4));
+  return { samples, sampleRate: SAMPLE_RATE, duration: samples.length / SAMPLE_RATE };
+}
+function cleanup(file) {
+  if (!file) return;
+  try {
+    fs4.rmSync(file, { force: true });
+  } catch {
+  }
+}
+
+// src/engine/onnx.ts
+var ISO_TO_NAME = {
+  en: "english",
+  es: "spanish",
+  fr: "french",
+  de: "german",
+  it: "italian",
+  pt: "portuguese",
+  nl: "dutch",
+  ru: "russian",
+  zh: "chinese",
+  ja: "japanese",
+  ko: "korean",
+  ar: "arabic",
+  hi: "hindi",
+  tr: "turkish",
+  pl: "polish",
+  uk: "ukrainian",
+  sv: "swedish",
+  cs: "czech",
+  da: "danish",
+  fi: "finnish"
+};
+var OnnxEngine = class _OnnxEngine {
+  kind = "onnx";
+  model;
+  device;
+  pipe = null;
+  constructor(model) {
+    this.model = model;
+    this.device = process.env.WHISPER_API_ONNX_DEVICE || "cpu";
+  }
+  describe() {
+    return `onnx (${this.device})`;
+  }
+  forModel(model) {
+    return new _OnnxEngine(model);
+  }
+  async getPipe(onProgress) {
+    if (this.pipe) return this.pipe;
+    const { pipeline: pipeline2, env } = await import("@huggingface/transformers");
+    env.cacheDir = paths.cache();
+    env.allowLocalModels = true;
+    const dtype = process.env.WHISPER_API_ONNX_DTYPE || (this.model.sizeMB > 1e3 ? "q8" : "fp32");
+    const pipe = await pipeline2("automatic-speech-recognition", this.model.onnxRepo, {
+      device: this.device,
+      dtype,
+      progress_callback: onProgress ? (p) => {
+        if (p.status === "progress" && typeof p.loaded === "number" && typeof p.total === "number") {
+          onProgress(p.loaded, p.total);
+        }
+      } : void 0
+    });
+    this.pipe = pipe;
+    return pipe;
+  }
+  async ensureModel(onProgress) {
+    await this.getPipe(onProgress);
+  }
+  async transcribe(inputPath, opts) {
+    const pipe = await this.getPipe();
+    const { samples, duration } = await toFloat32(inputPath);
+    const runOpts = {
+      return_timestamps: true,
+      chunk_length_s: 30,
+      stride_length_s: 5
+    };
+    if (!this.model.englishOnly) {
+      runOpts["task"] = opts.translate ? "translate" : "transcribe";
+      if (opts.language) runOpts["language"] = ISO_TO_NAME[opts.language] ?? opts.language;
+    }
+    if (typeof opts.temperature === "number") runOpts["temperature"] = opts.temperature;
+    const out = await pipe(samples, runOpts);
+    const segments = (out.chunks ?? []).map((c, i) => ({
+      id: i,
+      start: c.timestamp[0] ?? 0,
+      end: c.timestamp[1] ?? duration,
+      text: c.text.trim()
+    }));
+    return {
+      text: (out.text ?? "").trim(),
+      language: opts.language,
+      duration,
+      segments
+    };
+  }
+};
+
+// src/engine/whispercpp.ts
+import { spawn as spawn2 } from "child_process";
+import fs5 from "fs";
+import fsp3 from "fs/promises";
+import os2 from "os";
+import path4 from "path";
+import crypto3 from "crypto";
+var WhisperCppEngine = class _WhisperCppEngine {
+  kind = "whispercpp";
+  model;
+  bin;
+  gpu;
+  constructor(model, bin, gpu) {
+    this.model = model;
+    this.bin = bin;
+    this.gpu = gpu;
+  }
+  describe() {
+    return `whisper.cpp (${this.gpu ?? "cpu"})`;
+  }
+  forModel(model) {
+    return new _WhisperCppEngine(model, this.bin, this.gpu);
+  }
+  async ensureModel(onProgress) {
+    await downloadGgml(this.model, onProgress);
+  }
+  async transcribe(inputPath, opts) {
+    await this.ensureModel();
+    const wav = await toWav16k(inputPath);
+    const outPrefix = path4.join(paths.tmp(), `wcpp-${crypto3.randomBytes(8).toString("hex")}`);
+    const jsonPath = outPrefix + ".json";
+    const args = [
+      "-m",
+      ggmlPath(this.model),
+      "-f",
+      wav,
+      "-oj",
+      "-of",
+      outPrefix,
+      "-np",
+      "-t",
+      String(Math.max(1, os2.cpus().length))
+    ];
+    if (this.model.englishOnly) {
+      args.push("-l", "en");
+    } else {
+      args.push("-l", opts.language ?? "auto");
+    }
+    if (opts.translate) args.push("--translate");
+    if (typeof opts.temperature === "number") args.push("-tp", String(opts.temperature));
+    if (opts.prompt) args.push("--prompt", opts.prompt);
+    try {
+      await this.run(args);
+      const raw = await fsp3.readFile(jsonPath, "utf8");
+      return this.parse(JSON.parse(raw), opts);
+    } finally {
+      cleanup(wav);
+      cleanup(jsonPath);
+    }
+  }
+  run(args) {
+    return new Promise((resolve, reject) => {
+      const proc = spawn2(this.bin, args, { stdio: ["ignore", "ignore", "pipe"] });
+      const err = [];
+      proc.stderr.on("data", (d) => err.push(d));
+      proc.on("error", reject);
+      proc.on(
+        "close",
+        (code) => code === 0 ? resolve() : reject(new Error(`whisper-cli exited with code ${code}: ${Buffer.concat(err).toString("utf8").slice(-800)}`))
+      );
+    });
+  }
+  parse(data, opts) {
+    const items = data.transcription ?? [];
+    const segments = items.map((it, i) => ({
+      id: i,
+      start: (it.offsets?.from ?? 0) / 1e3,
+      end: (it.offsets?.to ?? 0) / 1e3,
+      text: (it.text ?? "").trim()
+    }));
+    const last = items[items.length - 1];
+    return {
+      text: items.map((it) => it.text ?? "").join("").trim(),
+      language: data.result?.language ?? data.params?.language ?? opts.language,
+      duration: last?.offsets?.to ? last.offsets.to / 1e3 : void 0,
+      segments
+    };
+  }
+};
+
+// src/engine/probe.ts
+import { spawn as spawn3, spawnSync } from "child_process";
+import fs6 from "fs";
+import os3 from "os";
+import path5 from "path";
+var WHISPER_CPP_REPO = "https://github.com/ggml-org/whisper.cpp";
+function which(cmd) {
+  const finder = process.platform === "win32" ? "where" : "which";
+  const r = spawnSync(finder, [cmd], { stdio: "ignore" });
+  return r.status === 0;
+}
+function hasBuildTools() {
+  const compiler = which("cc") || which("clang") || which("gcc") || which("c++");
+  return which("git") && which("cmake") && compiler;
+}
+function detectGpu() {
+  if (which("nvidia-smi")) return "cuda";
+  if (process.platform === "darwin" && os3.arch() === "arm64") return "metal";
+  return null;
+}
+function binCandidates() {
+  const exe = process.platform === "win32" ? ".exe" : "";
+  const names = [`whisper-cli${exe}`, `main${exe}`];
+  const out = [];
+  if (process.env.WHISPER_CPP_BIN) out.push(process.env.WHISPER_CPP_BIN);
+  for (const n of names) out.push(path5.join(paths.bin(), n));
+  return out;
+}
+function locateWhisperBinary() {
+  for (const c of binCandidates()) {
+    if (fs6.existsSync(c)) return c;
+  }
+  if (which("whisper-cli")) return "whisper-cli";
+  return null;
+}
+function step(cmd, args, cwd, onLog) {
+  return new Promise((resolve, reject) => {
+    onLog?.(`$ ${cmd} ${args.join(" ")}`);
+    const proc = spawn3(cmd, args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
+    const relay = (d) => onLog?.(d.toString("utf8").trimEnd());
+    proc.stdout.on("data", relay);
+    proc.stderr.on("data", relay);
+    proc.on("error", reject);
+    proc.on(
+      "close",
+      (code) => code === 0 ? resolve() : reject(new Error(`${cmd} exited with code ${code}`))
+    );
+  });
+}
+async function buildWhisperCpp(onLog) {
+  if (!hasBuildTools()) {
+    throw new Error("Build tools missing (need git, cmake and a C/C++ compiler).");
+  }
+  ensureDirs();
+  const srcDir = path5.join(paths.cache(), "whisper.cpp-src");
+  const buildDir = path5.join(srcDir, "build");
+  const gpu = detectGpu();
+  if (!fs6.existsSync(path5.join(srcDir, "CMakeLists.txt"))) {
+    fs6.rmSync(srcDir, { recursive: true, force: true });
+    await step("git", ["clone", "--depth", "1", WHISPER_CPP_REPO, srcDir], paths.cache(), onLog);
+  }
+  const cmakeArgs = [
+    "-S",
+    srcDir,
+    "-B",
+    buildDir,
+    "-DCMAKE_BUILD_TYPE=Release",
+    "-DWHISPER_BUILD_TESTS=OFF",
+    "-DWHISPER_BUILD_SERVER=OFF",
+    "-DWHISPER_BUILD_EXAMPLES=ON"
+  ];
+  if (gpu === "cuda") cmakeArgs.push("-DGGML_CUDA=ON");
+  await step("cmake", cmakeArgs, srcDir, onLog);
+  await step("cmake", ["--build", buildDir, "-j", String(Math.max(1, os3.cpus().length)), "--config", "Release"], srcDir, onLog);
+  const exe = process.platform === "win32" ? ".exe" : "";
+  const built = [
+    path5.join(buildDir, "bin", `whisper-cli${exe}`),
+    path5.join(buildDir, "bin", "Release", `whisper-cli${exe}`)
+  ].find((p) => fs6.existsSync(p));
+  if (!built) throw new Error("Build finished but whisper-cli binary was not found.");
+  const dest = path5.join(paths.bin(), `whisper-cli${exe}`);
+  fs6.copyFileSync(built, dest);
+  fs6.chmodSync(dest, 493);
+  onLog?.(`Installed whisper.cpp \u2192 ${dest}`);
+  return dest;
+}
+
+// src/engine/detect.ts
+async function createEngine(opts) {
+  const { engine, model, model: m } = opts;
+  const allowBuild = opts.allowBuild ?? process.env.WHISPER_API_AUTOBUILD === "1";
+  if (engine === "onnx") {
+    return { engine: new OnnxEngine(m), reason: "engine=onnx (portable, no compiler)" };
+  }
+  if (engine === "whispercpp") {
+    const bin = locateWhisperBinary() ?? await tryBuild(opts.onLog);
+    if (!bin) {
+      throw new Error(
+        "engine=whispercpp requested but no binary is available and it could not be built. Install build tools (git, cmake, a C/C++ compiler) and run `whisper-api build-engine`, set WHISPER_CPP_BIN, or use --engine onnx."
+      );
+    }
+    return { engine: new WhisperCppEngine(model, bin, detectGpu()), reason: "engine=whispercpp" };
+  }
+  const existing = locateWhisperBinary();
+  if (existing) {
+    return { engine: new WhisperCppEngine(model, existing, detectGpu()), reason: "auto \u2192 whisper.cpp (binary found)" };
+  }
+  if (allowBuild && hasBuildTools()) {
+    const built = await tryBuild(opts.onLog);
+    if (built) {
+      return { engine: new WhisperCppEngine(model, built, detectGpu()), reason: "auto \u2192 whisper.cpp (built from source)" };
+    }
+  }
+  return {
+    engine: new OnnxEngine(m),
+    reason: hasBuildTools() ? "auto \u2192 onnx (no whisper.cpp binary; run `whisper-api build-engine` for native speed)" : "auto \u2192 onnx (no whisper.cpp binary and no build toolchain)"
+  };
+}
+async function tryBuild(onLog) {
+  try {
+    return await buildWhisperCpp(onLog);
+  } catch (err) {
+    onLog?.(`whisper.cpp build failed: ${err.message}`);
+    return null;
+  }
+}
+
+// src/server/app.ts
+import { fileURLToPath } from "url";
+import fs8 from "fs";
+import Fastify from "fastify";
+import multipart from "@fastify/multipart";
+import rateLimit from "@fastify/rate-limit";
+import fastifyStatic from "@fastify/static";
+
+// src/server/formats.ts
+var RESPONSE_FORMATS = ["json", "verbose_json", "text", "srt", "vtt"];
+function isResponseFormat(v) {
+  return RESPONSE_FORMATS.includes(v);
+}
+function pad(n, width) {
+  return Math.floor(n).toString().padStart(width, "0");
+}
+function timestamp(seconds, sep) {
+  const ms = Math.round((seconds - Math.floor(seconds)) * 1e3);
+  const s = Math.floor(seconds) % 60;
+  const m = Math.floor(seconds / 60) % 60;
+  const h = Math.floor(seconds / 3600);
+  return `${pad(h, 2)}:${pad(m, 2)}:${pad(s, 2)}${sep}${pad(ms, 3)}`;
+}
+function toSrt(r) {
+  return r.segments.map((seg, i) => `${i + 1}
+${timestamp(seg.start, ",")} --> ${timestamp(seg.end, ",")}
+${seg.text}
+`).join("\n") + "\n";
+}
+function toVtt(r) {
+  const cues = r.segments.map((seg) => `${timestamp(seg.start, ".")} --> ${timestamp(seg.end, ".")}
+${seg.text}`).join("\n\n");
+  return `WEBVTT
+
+${cues}
+`;
+}
+function serialize(result, format) {
+  switch (format) {
+    case "text":
+      return { contentType: "text/plain; charset=utf-8", body: result.text + "\n" };
+    case "srt":
+      return { contentType: "text/plain; charset=utf-8", body: toSrt(result) };
+    case "vtt":
+      return { contentType: "text/vtt; charset=utf-8", body: toVtt(result) };
+    case "verbose_json":
+      return {
+        contentType: "application/json; charset=utf-8",
+        body: JSON.stringify({
+          task: "transcribe",
+          language: result.language ?? "unknown",
+          duration: result.duration ?? 0,
+          text: result.text,
+          segments: result.segments.map((seg) => ({
+            id: seg.id,
+            seek: 0,
+            start: seg.start,
+            end: seg.end,
+            text: seg.text,
+            tokens: [],
+            temperature: 0,
+            avg_logprob: 0,
+            compression_ratio: 0,
+            no_speech_prob: 0
+          }))
+        })
+      };
+    case "json":
+    default:
+      return { contentType: "application/json; charset=utf-8", body: JSON.stringify({ text: result.text }) };
+  }
+}
+function errorBody(message, type = "invalid_request_error", code = null) {
+  return { error: { message, type, param: null, code } };
+}
+
+// src/server/auth.ts
+var PUBLIC_PATHS = /* @__PURE__ */ new Set(["/health", "/", "/favicon.ico"]);
+function isPublic(url) {
+  const pathname = url.split("?")[0] ?? url;
+  return PUBLIC_PATHS.has(pathname) || !pathname.startsWith("/v1/") && !pathname.startsWith("/v1");
+}
+function extractBearer(header) {
+  if (!header) return null;
+  const m = /^Bearer\s+(.+)$/i.exec(header.trim());
+  return m ? m[1].trim() : null;
+}
+async function authHook(req, reply) {
+  if (isPublic(req.url)) return;
+  const token = extractBearer(req.headers.authorization);
+  if (!token) {
+    await reply.code(401).send(errorBody("Missing bearer token. Pass `Authorization: Bearer <key>`.", "invalid_request_error", "missing_api_key"));
+    return;
+  }
+  const record = await verifyKey(token);
+  if (!record) {
+    await reply.code(401).send(errorBody("Invalid or revoked API key.", "invalid_request_error", "invalid_api_key"));
+    return;
+  }
+  req.apiKey = record;
+}
+
+// src/server/routes/transcriptions.ts
+import fs7 from "fs";
+import path6 from "path";
+import crypto4 from "crypto";
+import { pipeline } from "stream/promises";
+async function parseMultipart(req) {
+  ensureDirs();
+  const result = { fields: {} };
+  for await (const part of req.parts()) {
+    if (part.type === "file") {
+      if (part.fieldname === "file") {
+        const ext = path6.extname(part.filename || "") || ".bin";
+        const dest = path6.join(paths.tmp(), `up-${crypto4.randomBytes(8).toString("hex")}${ext}`);
+        await pipeline(part.file, fs7.createWriteStream(dest));
+        result.filePath = dest;
+        result.filename = part.filename;
+        if (part.file.truncated) {
+          cleanup(dest);
+          throw Object.assign(new Error("Uploaded file exceeds the configured size limit."), { statusCode: 413 });
+        }
+      } else {
+        part.file.resume();
+      }
+    } else {
+      result.fields[part.fieldname] = String(part.value);
+    }
+  }
+  return result;
+}
+function registerTranscriptions(app, ctx) {
+  const handler = (translate) => async (req, reply) => {
+    let parsed;
+    try {
+      parsed = await parseMultipart(req);
+      if (!parsed.filePath) {
+        return reply.code(400).send(errorBody("Missing required `file` field.", "invalid_request_error", "missing_file"));
+      }
+      const fmtRaw = parsed.fields["response_format"] || "json";
+      if (!isResponseFormat(fmtRaw)) {
+        return reply.code(400).send(errorBody(`Unsupported response_format '${fmtRaw}'.`, "invalid_request_error"));
+      }
+      const format = fmtRaw;
+      const model = resolveModel(parsed.fields["model"], ctx.config.defaultModel);
+      const temperature = parsed.fields["temperature"] !== void 0 ? Number(parsed.fields["temperature"]) : void 0;
+      const task = parsed.fields["task"];
+      const engine = await ctx.getEngine(model.name);
+      const result = await engine.transcribe(parsed.filePath, {
+        language: parsed.fields["language"] || void 0,
+        translate: translate || task === "translate",
+        temperature: typeof temperature === "number" && !Number.isNaN(temperature) ? temperature : void 0,
+        prompt: parsed.fields["prompt"] || void 0
+      });
+      const { contentType, body } = serialize(result, format);
+      return reply.header("content-type", contentType).send(body);
+    } catch (err) {
+      const e = err;
+      const status = e.statusCode ?? 500;
+      req.log.error({ err: e }, "transcription failed");
+      return reply.code(status).send(errorBody(e.message || "Transcription failed.", status === 413 ? "invalid_request_error" : "server_error"));
+    } finally {
+      cleanup(parsed?.filePath);
+    }
+  };
+  const routeOpts = {
+    config: { rateLimit: { max: ctx.config.rateLimit.max, timeWindow: ctx.config.rateLimit.timeWindow } }
+  };
+  app.post("/v1/audio/transcriptions", routeOpts, handler(false));
+  app.post("/v1/audio/translations", routeOpts, handler(true));
+}
+
+// src/server/routes/models.ts
+function registerModels(app, ctx) {
+  const created = 17e8;
+  const entry = (id) => ({ id, object: "model", created, owned_by: "whisper-api" });
+  app.get("/v1/models", async () => ({
+    object: "list",
+    data: [entry("whisper-1"), ...MODELS.map((m) => entry(m.name))]
+  }));
+  app.get("/v1/models/:id", async (req, reply) => {
+    const id = req.params.id;
+    if (id === "whisper-1" || MODELS.some((m) => m.name === id)) {
+      return entry(id);
+    }
+    return reply.code(404).send({ error: { message: `Model '${id}' not found.`, type: "invalid_request_error" } });
+  });
+  app.get("/v1/models/active", async () => entry(ctx.defaultEngine.model.name));
+}
+
+// src/server/routes/health.ts
+function registerHealth(app, ctx) {
+  app.get("/health", async () => ({
+    status: "ok",
+    engine: ctx.engineLabel,
+    model: ctx.defaultEngine.model.name,
+    activeKeys: await countActiveKeys(),
+    uptime: Math.round(process.uptime()),
+    version: ctx.version
+  }));
+}
+
+// src/server/app.ts
+function findWebDir() {
+  for (const rel of ["../web", "../../web", "../../../web"]) {
+    const dir = fileURLToPath(new URL(rel, import.meta.url));
+    if (fs8.existsSync(dir)) return dir;
+  }
+  return null;
+}
+async function buildServer(ctx) {
+  const app = Fastify({
+    logger: process.env.WHISPER_API_LOG === "silent" ? false : { level: process.env.WHISPER_API_LOG || "info" },
+    bodyLimit: ctx.config.maxUploadBytes + 1024 * 1024
+  });
+  await app.register(multipart, {
+    limits: { fileSize: ctx.config.maxUploadBytes, files: 1, fields: 25 }
+  });
+  await app.register(rateLimit, {
+    global: false,
+    keyGenerator: (req) => extractBearer(req.headers.authorization) ?? req.ip,
+    errorResponseBuilder: () => errorBody("Rate limit exceeded. Slow down or request a higher limit.", "rate_limit_error", "rate_limit_exceeded")
+  });
+  app.addHook("onRequest", authHook);
+  app.setErrorHandler((err, req, reply) => {
+    const status = err.statusCode && err.statusCode >= 400 ? err.statusCode : 500;
+    req.log.error({ err }, "request error");
+    reply.code(status).send(errorBody(err.message || "Internal server error.", status >= 500 ? "server_error" : "invalid_request_error"));
+  });
+  registerHealth(app, ctx);
+  registerModels(app, ctx);
+  registerTranscriptions(app, ctx);
+  const webDir = findWebDir();
+  if (webDir) {
+    await app.register(fastifyStatic, { root: webDir, prefix: "/", index: ["index.html"] });
+  } else {
+    app.get("/", async () => ({ name: "whisper-api", status: "ok", docs: "/health" }));
+  }
+  return app;
+}
+async function startServer(ctx) {
+  const app = await buildServer(ctx);
+  await app.listen({ host: ctx.config.host, port: ctx.config.port });
+  const shown = ctx.config.host === "0.0.0.0" ? "localhost" : ctx.config.host;
+  return { app, url: `http://${shown}:${ctx.config.port}` };
+}
+
+// src/version.ts
+var VERSION = "0.1.0";
+
+// src/cli/ui.ts
+import cliProgress from "cli-progress";
+import pc from "picocolors";
+function mb(bytes) {
+  return Math.round(bytes / (1024 * 1024));
+}
+function modelProgress(label) {
+  const bar = new cliProgress.SingleBar(
+    { clearOnComplete: false, hideCursor: true, format: `  ${label} [{bar}] {percentage}% | {info}` },
+    cliProgress.Presets.shades_classic
+  );
+  let started = false;
+  return {
+    onProgress(received, total) {
+      if (!started) {
+        bar.start(total || 1, 0, { info: "" });
+        started = true;
+      }
+      if (total) bar.setTotal(total);
+      bar.update(received, { info: total ? `${mb(received)}/${mb(total)} MB` : `${mb(received)} MB` });
+    },
+    done() {
+      if (started) {
+        bar.update(bar.getTotal());
+        bar.stop();
+      } else {
+        console.log(`  ${label} ${pc.green("\u2713")} ${pc.dim("(already present)")}`);
+      }
+    }
+  };
+}
+function printAccessExample(baseUrl, key) {
+  const k = key ?? "sk-wapi-\u2026";
+  const note2 = key ? "" : pc.dim("  (generate one with: whisper-api key generate)\n");
+  console.log();
+  console.log(pc.bold("  Connect a third-party app to this endpoint:"));
+  console.log();
+  if (note2) console.log(note2.trimEnd());
+  console.log(pc.dim("  # curl"));
+  console.log(`  curl ${baseUrl}/v1/audio/transcriptions \\`);
+  console.log(`    -H ${pc.cyan(`"Authorization: Bearer ${k}"`)} \\`);
+  console.log(`    -F file=@audio.m4a -F model=whisper-1`);
+  console.log();
+  console.log(pc.dim("  # Python \u2014 official OpenAI SDK, just repoint base_url"));
+  console.log(`  from openai import OpenAI`);
+  console.log(`  client = OpenAI(base_url=${pc.cyan(`"${baseUrl}/v1"`)}, api_key=${pc.cyan(`"${k}"`)})`);
+  console.log(`  print(client.audio.transcriptions.create(`);
+  console.log(`      model="whisper-1", file=open("audio.m4a", "rb")).text)`);
+  console.log();
+  console.log(pc.dim("  # Node \u2014 official OpenAI SDK"));
+  console.log(`  import OpenAI from "openai";`);
+  console.log(`  const client = new OpenAI({ baseURL: ${pc.cyan(`"${baseUrl}/v1"`)}, apiKey: ${pc.cyan(`"${k}"`)} });`);
+  console.log();
+  console.log(pc.dim(`  # Any OpenAI-compatible app (Open WebUI, n8n, Raycast, LibreChat\u2026):`));
+  console.log(`  Base URL  ${pc.cyan(`${baseUrl}/v1`)}`);
+  console.log(`  API key   ${pc.cyan(k)}`);
+  console.log();
+}
+function printNewKey(raw, name, id) {
+  console.log();
+  console.log(pc.green("  \u2714 New API key \u2014 store it now, it is not recoverable:"));
+  console.log();
+  console.log(`      ${pc.bold(pc.cyan(raw))}`);
+  console.log();
+  console.log(pc.dim(`      id ${id}   name ${name}`));
+  console.log();
+}
+
+// src/cli/index.ts
+dotenv.config({ quiet: true });
+dotenv.config({ path: path7.join(homeDir(), ".env"), quiet: true });
+async function provision(engineChoice, model, label) {
+  const ui = modelProgress(label.padEnd(16));
+  try {
+    if (engineChoice === "onnx") {
+      await new OnnxEngine(model).ensureModel(ui.onProgress);
+    } else {
+      await downloadGgml(model, ui.onProgress);
+    }
+  } finally {
+    ui.done();
+  }
+}
+async function runInit() {
+  ensureDirs();
+  const existing = await loadConfig();
+  intro(pc.bold(" whisper-api setup "));
+  const engine = await select({
+    message: "Transcription engine",
+    initialValue: existing.engine,
+    options: [
+      { value: "auto", label: "auto", hint: "whisper.cpp if available, else portable ONNX" },
+      { value: "whispercpp", label: "whisper.cpp", hint: "fastest, GPU; needs build tools or a prebuilt binary" },
+      { value: "onnx", label: "onnx", hint: "pure-JS, no compiler, runs anywhere" }
+    ]
+  });
+  if (isCancel(engine)) return cancel("Setup cancelled.");
+  const chosen = await multiselect({
+    message: "Models to download (space to toggle)",
+    required: true,
+    initialValues: [existing.defaultModel],
+    options: MODELS.map((m) => ({ value: m.name, label: `${m.name}  ${pc.dim(`(${m.sizeMB} MB)`)}`, hint: m.description }))
+  });
+  if (isCancel(chosen)) return cancel("Setup cancelled.");
+  const selected = chosen;
+  let defaultModel = selected[0];
+  if (selected.length > 1) {
+    const d = await select({
+      message: "Default model (served for the `whisper-1` alias)",
+      initialValue: selected.includes(existing.defaultModel) ? existing.defaultModel : selected[0],
+      options: selected.map((n) => ({ value: n, label: n }))
+    });
+    if (isCancel(d)) return cancel("Setup cancelled.");
+    defaultModel = d;
+  }
+  const config = { ...DEFAULT_CONFIG, ...existing, engine, defaultModel };
+  await saveConfig(config);
+  const { raw, record } = await createKey("default");
+  note(`${pc.cyan(raw)}
+${pc.dim(`id ${record.id}`)}`, "API key \u2014 copy now, shown once");
+  console.log();
+  console.log(pc.bold(`  Downloading ${selected.length} model(s) for ${engine === "onnx" ? "ONNX" : "whisper.cpp"}\u2026`));
+  for (const name of selected) {
+    await provision(config.engine, findModel(name), name);
+  }
+  outro(pc.green("Setup complete."));
+  console.log(`  Config:  ${paths.config()}`);
+  console.log(`  Start:   ${pc.bold("whisper-api start")}`);
+  printAccessExample(`http://localhost:${config.port}`, raw);
+}
+async function runStart(opts) {
+  ensureDirs();
+  const config = applyEnvOverrides(await loadConfig());
+  if (opts.port) config.port = Number(opts.port);
+  if (opts.host) config.host = opts.host;
+  if (opts.engine) config.engine = opts.engine;
+  const model = resolveModel(opts.model || config.defaultModel, config.defaultModel);
+  const allowBuild = config.engine === "whispercpp" || process.env.WHISPER_API_AUTOBUILD === "1";
+  console.log(pc.dim(`  Selecting engine (${config.engine})\u2026`));
+  const selection = await createEngine({
+    engine: config.engine,
+    model,
+    allowBuild,
+    onLog: (l) => console.log(pc.dim("  " + l))
+  });
+  console.log(pc.dim(`  ${selection.reason}`));
+  const ui = modelProgress(`model ${model.name}`.padEnd(16));
+  try {
+    await selection.engine.ensureModel(ui.onProgress);
+  } finally {
+    ui.done();
+  }
+  const cache = /* @__PURE__ */ new Map([[model.name, selection.engine]]);
+  const getEngine = async (name) => {
+    const cached = cache.get(name);
+    if (cached) return cached;
+    const info = findModel(name) ?? model;
+    const eng = selection.engine.forModel(info);
+    cache.set(name, eng);
+    return eng;
+  };
+  const ctx = {
+    config,
+    defaultEngine: selection.engine,
+    engineLabel: selection.engine.describe(),
+    version: VERSION,
+    getEngine
+  };
+  const { url } = await startServer(ctx);
+  console.log();
+  console.log(
+    `  ${pc.green("\u25B6")} ${pc.bold("whisper-api")} on ${pc.cyan(url)}  ${pc.dim("\xB7")} engine ${pc.bold(
+      selection.engine.describe()
+    )} ${pc.dim("\xB7")} model ${pc.bold(model.name)}`
+  );
+  if (await countActiveKeys() === 0) {
+    console.log(`  ${pc.yellow("!")} No API keys yet \u2014 run ${pc.bold("whisper-api key generate")}`);
+  }
+  printAccessExample(url);
+}
+async function runModelsList() {
+  const config = await loadConfig();
+  console.log(pc.bold("  Models ") + pc.dim("(\u2713 = GGML present locally)"));
+  for (const m of MODELS) {
+    const mark = isGgmlInstalled(m) ? pc.green("\u2713") : pc.dim("\xB7");
+    const def = m.name === config.defaultModel ? pc.cyan("  (default)") : "";
+    console.log(`  ${mark} ${m.name.padEnd(16)} ${String(m.sizeMB).padStart(5)} MB  ${pc.dim(m.description)}${def}`);
+  }
+}
+async function runModelsPull(name) {
+  const model = findModel(name);
+  if (!model) {
+    console.error(pc.red(`Unknown model '${name}'. Run \`whisper-api models list\`.`));
+    process.exitCode = 1;
+    return;
+  }
+  const config = await loadConfig();
+  await provision(config.engine, model, name);
+  console.log(pc.green(`  \u2713 ${name} ready`));
+}
+async function runModelsRm(name) {
+  const model = findModel(name);
+  if (!model) {
+    console.error(pc.red(`Unknown model '${name}'.`));
+    process.exitCode = 1;
+    return;
+  }
+  const p = ggmlPath(model);
+  if (fs9.existsSync(p)) {
+    fs9.rmSync(p);
+    console.log(pc.green(`  \u2713 removed ${model.ggmlFile}`));
+  } else {
+    console.log(pc.dim(`  nothing to remove for ${name} (ONNX weights live under ${paths.cache()})`));
+  }
+}
+async function runKeyGenerate(opts) {
+  ensureDirs();
+  const { raw, record } = await createKey(opts.name || "default");
+  printNewKey(raw, record.name, record.id);
+  const config = await loadConfig();
+  printAccessExample(`http://localhost:${config.port}`, raw);
+}
+async function runKeyList() {
+  const keys = await listKeys();
+  if (!keys.length) {
+    console.log(pc.dim("  No keys yet. Create one: whisper-api key generate"));
+    return;
+  }
+  for (const k of keys) {
+    const state = k.revoked ? pc.red("revoked") : pc.green("active");
+    console.log(
+      `  ${k.prefix}\u2026  ${state}  ${pc.dim(k.id)}  name=${k.name}  created=${k.createdAt.slice(0, 10)}  lastUsed=${k.lastUsedAt ? k.lastUsedAt.slice(0, 10) : "never"}`
+    );
+  }
+}
+async function runKeyRevoke(idOrPrefix) {
+  const ok = await revokeKey(idOrPrefix);
+  console.log(ok ? pc.green(`  \u2713 revoked ${idOrPrefix}`) : pc.yellow(`  no active key matched ${idOrPrefix}`));
+}
+async function runStatus() {
+  const config = applyEnvOverrides(await loadConfig());
+  const installed = MODELS.filter(isGgmlInstalled).map((m) => m.name);
+  const bin = locateWhisperBinary();
+  console.log(pc.bold("  whisper-api status"));
+  console.log(`  home        ${homeDir()}`);
+  console.log(`  engine      ${config.engine}`);
+  console.log(`  default     ${config.defaultModel}`);
+  console.log(`  listen      ${config.host}:${config.port}`);
+  console.log(`  rate limit  ${config.rateLimit.max} / ${config.rateLimit.timeWindow} per key`);
+  console.log(`  ggml models ${installed.length ? installed.join(", ") : pc.dim("(none downloaded)")}`);
+  console.log(`  api keys    ${await countActiveKeys()} active`);
+  console.log(`  whisper.cpp ${bin ? pc.green(bin) : pc.dim("not built (run: whisper-api build-engine)")}`);
+}
+async function runBuildEngine() {
+  console.log(pc.bold("  Building whisper.cpp from source\u2026"));
+  try {
+    const bin = await buildWhisperCpp((l) => console.log(pc.dim("  " + l)));
+    console.log(pc.green(`  \u2713 built: ${bin}`));
+  } catch (e) {
+    console.error(pc.red(`  build failed: ${e.message}`));
+    process.exitCode = 1;
+  }
+}
+function buildProgram() {
+  const program2 = new Command();
+  program2.name("whisper-api").description("Self-hostable, OpenAI-compatible Whisper speech-to-text API server.").version(VERSION, "-v, --version").showHelpAfterError();
+  program2.command("init").description("Interactive setup: choose engine, download models, create an API key").action(runInit);
+  program2.command("start").description("Start the API server").option("-p, --port <port>", "port to listen on").option("--host <host>", "host to bind").option("-m, --model <name>", "default model (overrides config)").option("-e, --engine <engine>", "auto | whispercpp | onnx").action(runStart);
+  const models = program2.command("models").description("Manage local transcription models");
+  models.command("list").description("List available and installed models").action(runModelsList);
+  models.command("pull <name>").description("Download a model (e.g. base.en, large-v3)").action(runModelsPull);
+  models.command("rm <name>").description("Remove a downloaded GGML model").action(runModelsRm);
+  const key = program2.command("key").description("Manage API access keys");
+  key.command("generate").description("Generate a new API key").option("-n, --name <name>", "label for the key").action(runKeyGenerate);
+  key.command("list").description("List API keys").action(runKeyList);
+  key.command("revoke <idOrPrefix>").description("Revoke a key by id or prefix").action(runKeyRevoke);
+  program2.command("status").description("Show configuration and local state").action(runStatus);
+  program2.command("build-engine").description("Build whisper.cpp from source for native speed").action(runBuildEngine);
+  return program2;
+}
+var program = buildProgram();
+if (process.argv.slice(2).length === 0) {
+  program.outputHelp();
+  process.exit(0);
+}
+program.parseAsync(process.argv).catch((err) => {
+  console.error(pc.red(err.message));
+  process.exit(1);
+});
+//# sourceMappingURL=whisper-api.js.map