@storyteller-platform/ghost-story 0.0.1

package/dist/cli/install.d.ts

@@ -0,0 +1,62 @@
+import { BuildVariant, WhisperModel } from './config.js';
+
+interface DownloadOptions {
+    url: string;
+    destPath: string;
+    expectedSize?: number;
+    printOutput?: boolean;
+    onProgress?: ((downloaded: number, total: number) => void) | undefined;
+    signal?: AbortSignal | null | undefined;
+}
+declare function downloadFile(options: DownloadOptions): Promise<void>;
+declare class PlatformMismatchError extends Error {
+    readonly variant: BuildVariant;
+    readonly compatibleVariants: BuildVariant[];
+    constructor(variant: BuildVariant, compatibleVariants: BuildVariant[]);
+}
+interface InstallBinaryOptions {
+    variant?: BuildVariant | undefined;
+    printOutput?: boolean | undefined;
+    force?: boolean | undefined;
+    signal?: AbortSignal | null | undefined;
+}
+declare function installBinary(options?: InstallBinaryOptions): Promise<string>;
+interface InstallModelOptions {
+    model: WhisperModel;
+    modelDir?: string | undefined;
+    printOutput?: boolean;
+    force?: boolean;
+    onProgress?: ((downloaded: number, total: number) => void) | undefined;
+    signal?: AbortSignal | null | undefined;
+}
+declare function installModel(options: InstallModelOptions): Promise<string>;
+interface InstallCoremlModelOptions {
+    model: WhisperModel;
+    modelDir?: string;
+    printOutput?: boolean;
+    force?: boolean;
+    signal?: AbortSignal | null | undefined;
+}
+declare function installCoremlModel(options: InstallCoremlModelOptions): Promise<string>;
+interface InstallVadModelOptions {
+    modelDir?: string;
+    printOutput?: boolean;
+    force?: boolean;
+    onProgress?: (downloaded: number, total: number) => void;
+    signal?: AbortSignal | null | undefined;
+}
+declare function installVadModel(options?: InstallVadModelOptions): Promise<string>;
+interface EnsureInstalledOptions {
+    model?: WhisperModel | undefined;
+    variant?: BuildVariant | undefined;
+    modelDir?: string | undefined;
+    printOutput?: boolean | undefined;
+    force?: boolean | undefined;
+    signal?: AbortSignal | null | undefined;
+}
+declare function ensureWhisperInstalled(options?: EnsureInstalledOptions): Promise<{
+    installDir: string;
+    modelPath: string | null;
+}>;
+
+export { type DownloadOptions, type EnsureInstalledOptions, type InstallBinaryOptions, type InstallCoremlModelOptions, type InstallModelOptions, type InstallVadModelOptions, PlatformMismatchError, downloadFile, ensureWhisperInstalled, installBinary, installCoremlModel, installModel, installVadModel };

package/dist/cli/install.js

@@ -0,0 +1,316 @@
+import {
+  createReadStream,
+  createWriteStream,
+  existsSync,
+  statSync
+} from "node:fs";
+import { mkdir, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { pipeline } from "node:stream/promises";
+import { createGunzip } from "node:zlib";
+import { extract } from "tar";
+import {
+  MODEL_SIZES,
+  detectPlatform,
+  getBinaryDownloadUrl,
+  getCompatibleVariants,
+  getCoremlModelDownloadUrl,
+  getCoremlModelPath,
+  getInstallDir,
+  getInstalledVariant,
+  getModelDir,
+  getModelDownloadUrl,
+  getModelPath,
+  getVadModelDownloadUrl,
+  getVadModelPath,
+  getWhisperExecutablePath,
+  isVariantCompatibleWithCurrentPlatform,
+  needsCoremlModel
+} from "./config.js";
+async function downloadFile(options) {
+  const {
+    url,
+    destPath,
+    expectedSize,
+    printOutput = true,
+    onProgress,
+    signal
+  } = options;
+  console.log(`Downloading file from ${url} to ${destPath}`);
+  const response = await fetch(url, { signal: signal ?? null });
+  if (!response.ok) {
+    throw new Error(
+      `Failed to download: ${response.status} ${response.statusText}`
+    );
+  }
+  const contentLength = response.headers.get("content-length");
+  const totalSize = contentLength ? parseInt(contentLength, 10) : expectedSize ?? 0;
+  if (!response.body) {
+    throw new Error("Response body is null");
+  }
+  await mkdir(path.dirname(destPath), { recursive: true });
+  const fileStream = createWriteStream(destPath);
+  const reader = response.body.getReader();
+  let downloaded = 0;
+  let lastPrinted = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      downloaded += value.length;
+      fileStream.write(value);
+      onProgress == null ? void 0 : onProgress(downloaded, totalSize);
+      if (printOutput && totalSize > 0) {
+        const shouldPrint = downloaded - lastPrinted > 10 * 1024 * 1024 || downloaded === totalSize;
+        if (shouldPrint) {
+          const percent = (downloaded / totalSize * 100).toFixed(1);
+          console.log(
+            `  ${(downloaded / 1024 / 1024).toFixed(1)} MB / ${(totalSize / 1024 / 1024).toFixed(1)} MB (${percent}%)`
+          );
+          lastPrinted = downloaded;
+        }
+      }
+    }
+  } finally {
+    fileStream.end();
+  }
+  await new Promise((resolve, reject) => {
+    fileStream.on("finish", resolve);
+    fileStream.on("error", reject);
+  });
+}
+class PlatformMismatchError extends Error {
+  constructor(variant, compatibleVariants) {
+    const compatible = compatibleVariants.join(", ");
+    super(
+      `Variant "${variant}" is not compatible with the current platform. Compatible variants: ${compatible}. Use --force to override.`
+    );
+    this.variant = variant;
+    this.compatibleVariants = compatibleVariants;
+    this.name = "PlatformMismatchError";
+  }
+}
+async function installBinary(options = {}) {
+  const {
+    variant = getInstalledVariant() ?? detectPlatform(),
+    printOutput = true,
+    force = false,
+    signal
+  } = options;
+  if (!force && !isVariantCompatibleWithCurrentPlatform(variant)) {
+    throw new PlatformMismatchError(variant, getCompatibleVariants());
+  }
+  const installDir = getInstallDir(variant);
+  const executablePath = getWhisperExecutablePath(installDir);
+  if (!force && existsSync(executablePath)) {
+    if (printOutput) {
+      console.log(`whisper.cpp (${variant}) already installed at ${installDir}`);
+    }
+    return installDir;
+  }
+  if (force && existsSync(installDir)) {
+    if (printOutput) {
+      console.log(`Removing existing installation at ${installDir}`);
+    }
+    await rm(installDir, { recursive: true });
+  }
+  const url = getBinaryDownloadUrl(variant);
+  const tmpDir = path.join(os.tmpdir(), "ghost-story-whisper-install");
+  const tarballPath = path.join(tmpDir, `whisper-cpp-${variant}.tar.gz`);
+  if (printOutput) {
+    console.log(`Downloading whisper.cpp (${variant}) from ${url}`);
+  }
+  await downloadFile({
+    url,
+    destPath: tarballPath,
+    printOutput,
+    signal
+  });
+  if (printOutput) {
+    console.log(`Extracting to ${installDir}`);
+  }
+  await mkdir(installDir, { recursive: true });
+  await pipeline(
+    createReadStream(tarballPath),
+    createGunzip(),
+    extract({ cwd: installDir, strip: 1 })
+  );
+  await rm(tmpDir, { recursive: true }).catch(() => {
+  });
+  if (printOutput) {
+    console.log(`whisper.cpp (${variant}) installed successfully`);
+  }
+  return installDir;
+}
+async function installModel(options) {
+  const {
+    model,
+    modelDir = getModelDir(),
+    printOutput = true,
+    force = false,
+    onProgress,
+    signal
+  } = options;
+  const modelPath = getModelPath(model, modelDir);
+  const expectedSize = MODEL_SIZES[model];
+  if (!force && existsSync(modelPath)) {
+    const stats = statSync(modelPath);
+    if (stats.size === expectedSize) {
+      if (printOutput) {
+        console.log(`Model ${model} already exists at ${modelPath}`);
+      }
+      const installedVariant2 = getInstalledVariant();
+      if (needsCoremlModel(installedVariant2 ?? void 0)) {
+        await installCoremlModel({
+          model,
+          modelDir,
+          printOutput,
+          force,
+          signal
+        });
+      }
+      return modelPath;
+    }
+    if (printOutput) {
+      console.log(
+        `Model ${model} exists but has wrong size (${stats.size} vs ${expectedSize}), re-downloading`
+      );
+    }
+  }
+  const url = getModelDownloadUrl(model);
+  if (printOutput) {
+    console.log(`Downloading model ${model}`);
+  }
+  await downloadFile({
+    url,
+    destPath: modelPath,
+    expectedSize,
+    printOutput,
+    onProgress,
+    signal
+  });
+  const installedVariant = getInstalledVariant();
+  if (needsCoremlModel(installedVariant ?? void 0)) {
+    await installCoremlModel({ model, modelDir, printOutput, force, signal });
+  }
+  if (printOutput) {
+    console.log(`Model ${model} installed successfully`);
+  }
+  return modelPath;
+}
+async function installCoremlModel(options) {
+  const {
+    model,
+    modelDir = getModelDir(),
+    printOutput = true,
+    force = false,
+    signal
+  } = options;
+  const coremlPath = getCoremlModelPath(model, modelDir);
+  if (!force && existsSync(coremlPath)) {
+    if (printOutput) {
+      console.log(`CoreML model ${model} already exists at ${coremlPath}`);
+    }
+    return coremlPath;
+  }
+  const url = getCoremlModelDownloadUrl(model);
+  const tmpDir = path.join(os.tmpdir(), "ghost-story-coreml-install");
+  const tarballPath = path.join(tmpDir, `ggml-${model}-encoder.mlmodelc.tar.gz`);
+  if (printOutput) {
+    console.log(`Downloading CoreML model ${model}`);
+  }
+  await downloadFile({
+    url,
+    destPath: tarballPath,
+    printOutput,
+    signal
+  });
+  if (printOutput) {
+    console.log(`Extracting CoreML model to ${modelDir}`);
+  }
+  await mkdir(modelDir, { recursive: true });
+  await pipeline(
+    createReadStream(tarballPath),
+    createGunzip(),
+    extract({ cwd: modelDir })
+  );
+  await rm(tmpDir, { recursive: true }).catch(() => {
+  });
+  if (printOutput) {
+    console.log(`CoreML model ${model} installed successfully`);
+  }
+  return coremlPath;
+}
+async function installVadModel(options = {}) {
+  const {
+    modelDir = getModelDir(),
+    printOutput = true,
+    force = false,
+    onProgress,
+    signal
+  } = options;
+  const modelPath = getVadModelPath(modelDir);
+  const expectedSize = MODEL_SIZES["silero-vad"];
+  if (!force && existsSync(modelPath)) {
+    const stats = statSync(modelPath);
+    if (stats.size === expectedSize) {
+      if (printOutput) {
+        console.log(`VAD model already exists at ${modelPath}`);
+      }
+      return modelPath;
+    }
+    if (printOutput) {
+      console.log(
+        `VAD model exists but has wrong size (${stats.size} vs ${expectedSize}), re-downloading`
+      );
+    }
+  }
+  const url = getVadModelDownloadUrl();
+  if (printOutput) {
+    console.log(`Downloading Silero VAD model`);
+  }
+  await downloadFile({
+    url,
+    destPath: modelPath,
+    expectedSize,
+    printOutput,
+    onProgress,
+    signal
+  });
+  if (printOutput) {
+    console.log(`VAD model installed successfully`);
+  }
+  return modelPath;
+}
+async function ensureWhisperInstalled(options = {}) {
+  const { model, variant, printOutput = false, force = false, signal } = options;
+  const installDir = await installBinary({
+    variant,
+    printOutput,
+    force,
+    signal
+  });
+  let modelPath = null;
+  if (model) {
+    modelPath = await installModel({
+      model,
+      modelDir: options.modelDir,
+      printOutput,
+      force,
+      signal
+    });
+  }
+  return { installDir, modelPath };
+}
+export {
+  PlatformMismatchError,
+  downloadFile,
+  ensureWhisperInstalled,
+  installBinary,
+  installCoremlModel,
+  installModel,
+  installVadModel
+};

package/dist/cli/whisper-server.cjs

@@ -0,0 +1,172 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var whisper_server_exports = {};
+__export(whisper_server_exports, {
+  IncompatibleBinaryError: () => IncompatibleBinaryError,
+  defaultServerOptions: () => defaultServerOptions,
+  spawnWhisperServer: () => spawnWhisperServer
+});
+module.exports = __toCommonJS(whisper_server_exports);
+var import_node_child_process = require("node:child_process");
+var import_node_fs = require("node:fs");
+var import_config = require("./config.cjs");
+var import_install = require("./install.cjs");
+const defaultServerOptions = {
+  model: "tiny.en",
+  port: 8080,
+  host: "0.0.0.0",
+  threads: 4,
+  processors: 4,
+  convert: true,
+  autoInstall: true
+};
+class IncompatibleBinaryError extends Error {
+  constructor(installedVariant) {
+    super(
+      `Installed binary "${installedVariant}" is not compatible with the current platform. Reinstall with a compatible variant or use --force to attempt running anyway.`
+    );
+    this.installedVariant = installedVariant;
+    this.name = "IncompatibleBinaryError";
+  }
+}
+async function spawnWhisperServer(options) {
+  const installedVariant = (0, import_config.getInstalledVariant)();
+  if (installedVariant && !options.force) {
+    if (!(0, import_config.isVariantCompatibleWithCurrentPlatform)(installedVariant)) {
+      throw new IncompatibleBinaryError(installedVariant);
+    }
+  }
+  const installDir = options.variant ? (0, import_config.getInstallDir)(options.variant) : (0, import_config.getInstallDir)();
+  const modelPath = (0, import_config.getModelPath)(options.model);
+  console.log("Setting up whisper.cpp server...");
+  console.log(`  Model: ${options.model}`);
+  console.log(`  Port: ${options.port}`);
+  console.log(`  Host: ${options.host}`);
+  console.log(`  Threads: ${options.threads}`);
+  console.log(`  Processors: ${options.processors}`);
+  if (installedVariant) {
+    console.log(`  Variant: ${installedVariant}`);
+  }
+  console.log("");
+  const serverPath = (0, import_config.getWhisperServerExecutablePath)(installDir);
+  if (options.autoInstall) {
+    if (!(0, import_node_fs.existsSync)(serverPath)) {
+      console.log("Installing whisper.cpp binary...");
+      await (0, import_install.installBinary)({
+        variant: options.variant,
+        printOutput: true,
+        force: options.force
+      });
+      console.log("");
+    }
+    if ((0, import_node_fs.existsSync)(serverPath) && !((0, import_node_fs.statSync)(serverPath).mode & 73)) {
+      console.log("Making whisper.cpp binary executable...");
+      (0, import_node_fs.chmodSync)(serverPath, 493);
+    }
+    if (!(0, import_node_fs.existsSync)(modelPath)) {
+      console.log(`Installing model ${options.model}...`);
+      await (0, import_install.installModel)({ model: options.model, printOutput: true });
+      console.log("");
+    }
+  }
+  if (!(0, import_node_fs.existsSync)(serverPath)) {
+    console.error(`Server executable not found at ${serverPath}`);
+    console.error("Run 'storywhisper install binary' to install whisper.cpp");
+    process.exit(1);
+  }
+  if (!(0, import_node_fs.existsSync)(modelPath)) {
+    console.error(`Model not found at ${modelPath}`);
+    console.error(
+      `Run 'storywhisper install model ${options.model}' to install the model`
+    );
+    process.exit(1);
+  }
+  console.log("Starting whisper server...");
+  console.log(`  Executable: ${serverPath}`);
+  console.log(`  Model: ${modelPath}`);
+  console.log("");
+  const serverArgs = [
+    "-m",
+    modelPath,
+    "--host",
+    options.host,
+    "--port",
+    String(options.port),
+    "-t",
+    String(options.threads),
+    "-p",
+    String(options.processors),
+    "--inference-path",
+    "/audio/transcriptions",
+    "--suppress-nst",
+    "--flash-attn"
+  ];
+  if (options.convert) {
+    serverArgs.push("--convert");
+  }
+  if (options.vadModelPath) {
+    serverArgs.push("--vad", "--vad-model", options.vadModelPath);
+    if (options.vadThreshold !== void 0) {
+      serverArgs.push("--vad-threshold", String(options.vadThreshold));
+    }
+  }
+  try {
+    const server = (0, import_node_child_process.spawn)(serverPath, serverArgs, {
+      stdio: "inherit",
+      cwd: installDir
+    });
+    server.on("error", (err) => {
+      console.error("Failed to start server:", err.message);
+      if (err.message.includes("ENOEXEC")) {
+        const variant = (0, import_config.getInstalledVariant)();
+        console.error(
+          `The installed binary${variant ? ` (${variant})` : ""} cannot be executed on this platform.`
+        );
+        console.error(
+          "Reinstall with a compatible variant: storywhisper install binary --force"
+        );
+      }
+      process.exit(1);
+    });
+    server.on("exit", (code, signal) => {
+      if (signal) {
+        console.log(`Server terminated by signal: ${signal}`);
+      } else {
+        console.log(`Server exited with code: ${code}`);
+      }
+    });
+    process.on("SIGINT", () => {
+      console.log("\nShutting down server...");
+      server.kill("SIGTERM");
+    });
+    process.on("SIGTERM", () => {
+      server.kill("SIGTERM");
+    });
+    return server;
+  } catch (error) {
+    console.error("Failed to start server:", error);
+    process.exit(1);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  IncompatibleBinaryError,
+  defaultServerOptions,
+  spawnWhisperServer
+});

package/dist/cli/whisper-server.d.cts

@@ -0,0 +1,24 @@
+import * as child_process from 'child_process';
+import { WhisperModel, BuildVariant } from './config.cjs';
+
+interface ServerOptions {
+    model: WhisperModel;
+    port: number;
+    host: string;
+    threads: number;
+    processors: number;
+    convert: boolean;
+    autoInstall: boolean;
+    variant?: BuildVariant | undefined;
+    force?: boolean | undefined;
+    vadModelPath?: string | undefined;
+    vadThreshold?: number | undefined;
+}
+declare const defaultServerOptions: ServerOptions;
+declare class IncompatibleBinaryError extends Error {
+    readonly installedVariant: BuildVariant;
+    constructor(installedVariant: BuildVariant);
+}
+declare function spawnWhisperServer(options: ServerOptions): Promise<child_process.ChildProcess>;
+
+export { IncompatibleBinaryError, type ServerOptions, defaultServerOptions, spawnWhisperServer };

package/dist/cli/whisper-server.d.ts

@@ -0,0 +1,24 @@
+import * as child_process from 'child_process';
+import { WhisperModel, BuildVariant } from './config.js';
+
+interface ServerOptions {
+    model: WhisperModel;
+    port: number;
+    host: string;
+    threads: number;
+    processors: number;
+    convert: boolean;
+    autoInstall: boolean;
+    variant?: BuildVariant | undefined;
+    force?: boolean | undefined;
+    vadModelPath?: string | undefined;
+    vadThreshold?: number | undefined;
+}
+declare const defaultServerOptions: ServerOptions;
+declare class IncompatibleBinaryError extends Error {
+    readonly installedVariant: BuildVariant;
+    constructor(installedVariant: BuildVariant);
+}
+declare function spawnWhisperServer(options: ServerOptions): Promise<child_process.ChildProcess>;
+
+export { IncompatibleBinaryError, type ServerOptions, defaultServerOptions, spawnWhisperServer };