@storyteller-platform/ghost-story 0.0.1

package/dist/cli/whisper-server.js

@@ -0,0 +1,152 @@
+import { spawn } from "node:child_process";
+import { chmodSync, existsSync, statSync } from "node:fs";
+import {
+  getInstallDir,
+  getInstalledVariant,
+  getModelPath,
+  getWhisperServerExecutablePath,
+  isVariantCompatibleWithCurrentPlatform
+} from "./config.js";
+import { installBinary, installModel } from "./install.js";
+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 = getInstalledVariant();
+  if (installedVariant && !options.force) {
+    if (!isVariantCompatibleWithCurrentPlatform(installedVariant)) {
+      throw new IncompatibleBinaryError(installedVariant);
+    }
+  }
+  const installDir = options.variant ? getInstallDir(options.variant) : getInstallDir();
+  const modelPath = 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 = getWhisperServerExecutablePath(installDir);
+  if (options.autoInstall) {
+    if (!existsSync(serverPath)) {
+      console.log("Installing whisper.cpp binary...");
+      await installBinary({
+        variant: options.variant,
+        printOutput: true,
+        force: options.force
+      });
+      console.log("");
+    }
+    if (existsSync(serverPath) && !(statSync(serverPath).mode & 73)) {
+      console.log("Making whisper.cpp binary executable...");
+      chmodSync(serverPath, 493);
+    }
+    if (!existsSync(modelPath)) {
+      console.log(`Installing model ${options.model}...`);
+      await installModel({ model: options.model, printOutput: true });
+      console.log("");
+    }
+  }
+  if (!existsSync(serverPath)) {
+    console.error(`Server executable not found at ${serverPath}`);
+    console.error("Run 'storywhisper install binary' to install whisper.cpp");
+    process.exit(1);
+  }
+  if (!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 = 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 = 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);
+  }
+}
+export {
+  IncompatibleBinaryError,
+  defaultServerOptions,
+  spawnWhisperServer
+};

package/dist/config.cjs

@@ -0,0 +1,60 @@
+"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 config_exports = {};
+__export(config_exports, {
+  getConfig: () => getConfig,
+  getConversionMode: () => getConversionMode,
+  isTimingEnabled: () => isTimingEnabled,
+  setConversionMode: () => setConversionMode,
+  setTimingEnabled: () => setTimingEnabled
+});
+module.exports = __toCommonJS(config_exports);
+const config = {
+  conversionMode: getConversionModeFromEnv(),
+  enableTiming: true
+  // process.env["GHOST_STORY_TIMING"] ? process.env["GHOST_STORY_TIMING"] === "true" : true,
+};
+function getConversionModeFromEnv() {
+  const envValue = process.env["GHOST_STORY_CONVERSION_MODE"];
+  if (envValue === "streaming") return "streaming";
+  return "file-first";
+}
+function getConfig() {
+  return { ...config };
+}
+function setConversionMode(mode) {
+  config.conversionMode = mode;
+}
+function setTimingEnabled(enabled) {
+  config.enableTiming = enabled;
+}
+function getConversionMode() {
+  return config.conversionMode;
+}
+function isTimingEnabled() {
+  return config.enableTiming;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getConfig,
+  getConversionMode,
+  isTimingEnabled,
+  setConversionMode,
+  setTimingEnabled
+});

package/dist/config.d.cts

@@ -0,0 +1,12 @@
+type ConversionMode = "file-first" | "streaming";
+interface GhostStoryConfig {
+    conversionMode: ConversionMode;
+    enableTiming: boolean;
+}
+declare function getConfig(): GhostStoryConfig;
+declare function setConversionMode(mode: ConversionMode): void;
+declare function setTimingEnabled(enabled: boolean): void;
+declare function getConversionMode(): ConversionMode;
+declare function isTimingEnabled(): boolean;
+
+export { type ConversionMode, getConfig, getConversionMode, isTimingEnabled, setConversionMode, setTimingEnabled };

package/dist/config.d.ts

@@ -0,0 +1,12 @@
+type ConversionMode = "file-first" | "streaming";
+interface GhostStoryConfig {
+    conversionMode: ConversionMode;
+    enableTiming: boolean;
+}
+declare function getConfig(): GhostStoryConfig;
+declare function setConversionMode(mode: ConversionMode): void;
+declare function setTimingEnabled(enabled: boolean): void;
+declare function getConversionMode(): ConversionMode;
+declare function isTimingEnabled(): boolean;
+
+export { type ConversionMode, getConfig, getConversionMode, isTimingEnabled, setConversionMode, setTimingEnabled };

package/dist/config.js

@@ -0,0 +1,32 @@
+const config = {
+  conversionMode: getConversionModeFromEnv(),
+  enableTiming: true
+  // process.env["GHOST_STORY_TIMING"] ? process.env["GHOST_STORY_TIMING"] === "true" : true,
+};
+function getConversionModeFromEnv() {
+  const envValue = process.env["GHOST_STORY_CONVERSION_MODE"];
+  if (envValue === "streaming") return "streaming";
+  return "file-first";
+}
+function getConfig() {
+  return { ...config };
+}
+function setConversionMode(mode) {
+  config.conversionMode = mode;
+}
+function setTimingEnabled(enabled) {
+  config.enableTiming = enabled;
+}
+function getConversionMode() {
+  return config.conversionMode;
+}
+function isTimingEnabled() {
+  return config.enableTiming;
+}
+export {
+  getConfig,
+  getConversionMode,
+  isTimingEnabled,
+  setConversionMode,
+  setTimingEnabled
+};

package/dist/convert.cjs

@@ -0,0 +1,88 @@
+"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 convert_exports = {};
+__export(convert_exports, {
+  fileToFormat: () => fileToFormat,
+  fileToWav: () => fileToWav
+});
+module.exports = __toCommonJS(convert_exports);
+var import_node_os = require("node:os");
+var import_node_path = require("node:path");
+var import_ffmpeg_stream = require("ffmpeg-stream");
+var import_AudioFormat = require("./audio/AudioFormat.cjs");
+async function fileToWav(file, options = {}) {
+  const converter = new import_ffmpeg_stream.Converter();
+  const outputPath = (0, import_node_path.join)((0, import_node_os.tmpdir)(), `vad-${Date.now()}.wav`);
+  converter.createInputFromFile(file);
+  converter.createOutputToFile(outputPath, {
+    f: "wav",
+    ar: String(options.sampleRate ?? 16e3),
+    ac: String(options.channels ?? 1)
+  });
+  await converter.run();
+  return outputPath;
+}
+async function fileToFormat(file, targetFormat, options = {}) {
+  const converter = new import_ffmpeg_stream.Converter();
+  const ext = (0, import_AudioFormat.formatToExtension)(targetFormat);
+  const outputPath = (0, import_node_path.join)((0, import_node_os.tmpdir)(), `convert-${Date.now()}${ext}`);
+  converter.createInputFromFile(file);
+  converter.createOutputToFile(outputPath, getFormatOptions(targetFormat, options));
+  await converter.run();
+  return outputPath;
+}
+function getFormatOptions(format, options) {
+  const opts = {};
+  switch (format) {
+    case "wav":
+      opts["f"] = "wav";
+      opts["acodec"] = "pcm_s16le";
+      break;
+    case "flac":
+      opts["f"] = "flac";
+      opts["acodec"] = "flac";
+      break;
+    case "opus":
+      opts["f"] = "ogg";
+      opts["acodec"] = "libopus";
+      break;
+    case "ogg":
+      opts["f"] = "ogg";
+      opts["acodec"] = "libvorbis";
+      break;
+    case "mp3":
+      opts["f"] = "mp3";
+      opts["acodec"] = "libmp3lame";
+      break;
+    default:
+      opts["f"] = format;
+  }
+  if (options.sampleRate) {
+    opts["ar"] = String(options.sampleRate);
+  }
+  if (options.channels) {
+    opts["ac"] = String(options.channels);
+  }
+  return opts;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  fileToFormat,
+  fileToWav
+});

package/dist/convert.d.cts

@@ -0,0 +1,12 @@
+import { AudioFormat } from './audio/AudioFormat.cjs';
+
+declare function fileToWav(file: string, options?: {
+    sampleRate?: number;
+    channels?: number;
+}): Promise<string>;
+declare function fileToFormat(file: string, targetFormat: AudioFormat, options?: {
+    sampleRate?: number;
+    channels?: number;
+}): Promise<string>;
+
+export { fileToFormat, fileToWav };

package/dist/convert.d.ts

@@ -0,0 +1,12 @@
+import { AudioFormat } from './audio/AudioFormat.js';
+
+declare function fileToWav(file: string, options?: {
+    sampleRate?: number;
+    channels?: number;
+}): Promise<string>;
+declare function fileToFormat(file: string, targetFormat: AudioFormat, options?: {
+    sampleRate?: number;
+    channels?: number;
+}): Promise<string>;
+
+export { fileToFormat, fileToWav };

package/dist/convert.js

@@ -0,0 +1,63 @@
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Converter } from "ffmpeg-stream";
+import { formatToExtension } from "./audio/AudioFormat.js";
+async function fileToWav(file, options = {}) {
+  const converter = new Converter();
+  const outputPath = join(tmpdir(), `vad-${Date.now()}.wav`);
+  converter.createInputFromFile(file);
+  converter.createOutputToFile(outputPath, {
+    f: "wav",
+    ar: String(options.sampleRate ?? 16e3),
+    ac: String(options.channels ?? 1)
+  });
+  await converter.run();
+  return outputPath;
+}
+async function fileToFormat(file, targetFormat, options = {}) {
+  const converter = new Converter();
+  const ext = formatToExtension(targetFormat);
+  const outputPath = join(tmpdir(), `convert-${Date.now()}${ext}`);
+  converter.createInputFromFile(file);
+  converter.createOutputToFile(outputPath, getFormatOptions(targetFormat, options));
+  await converter.run();
+  return outputPath;
+}
+function getFormatOptions(format, options) {
+  const opts = {};
+  switch (format) {
+    case "wav":
+      opts["f"] = "wav";
+      opts["acodec"] = "pcm_s16le";
+      break;
+    case "flac":
+      opts["f"] = "flac";
+      opts["acodec"] = "flac";
+      break;
+    case "opus":
+      opts["f"] = "ogg";
+      opts["acodec"] = "libopus";
+      break;
+    case "ogg":
+      opts["f"] = "ogg";
+      opts["acodec"] = "libvorbis";
+      break;
+    case "mp3":
+      opts["f"] = "mp3";
+      opts["acodec"] = "libmp3lame";
+      break;
+    default:
+      opts["f"] = format;
+  }
+  if (options.sampleRate) {
+    opts["ar"] = String(options.sampleRate);
+  }
+  if (options.channels) {
+    opts["ac"] = String(options.channels);
+  }
+  return opts;
+}
+export {
+  fileToFormat,
+  fileToWav
+};

package/dist/encodings/Ascii.cjs

@@ -0,0 +1,75 @@
+"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 Ascii_exports = {};
+__export(Ascii_exports, {
+  ChunkedAsciiDecoder: () => ChunkedAsciiDecoder,
+  decodeAscii: () => decodeAscii,
+  encodeAscii: () => encodeAscii,
+  encodeAsciiInto: () => encodeAsciiInto
+});
+module.exports = __toCommonJS(Ascii_exports);
+function encodeAscii(asciiString) {
+  const charCount = asciiString.length;
+  const resultArray = new Uint8Array(charCount);
+  const { written } = encodeAsciiInto(asciiString, resultArray);
+  return resultArray.subarray(0, written);
+}
+function encodeAsciiInto(asciiString, resultBuffer) {
+  const len = asciiString.length;
+  if (resultBuffer.length < len) {
+    throw new Error(`Result Uint8Array is not large enough to hold the string`);
+  }
+  for (let readOffset = 0; readOffset < len; readOffset++) {
+    const charCode = asciiString.charCodeAt(readOffset);
+    if (charCode >= 128) {
+      throw new Error(
+        `Character '${asciiString[readOffset]}' (code: ${charCode}) can't be encoded as a standard ASCII character`
+      );
+    }
+    resultBuffer[readOffset] = charCode;
+  }
+  return { read: len, written: len };
+}
+function decodeAscii(encodedString) {
+  const maxChunkLength = 2 ** 24;
+  const decoder = new ChunkedAsciiDecoder();
+  for (let offset = 0; offset < encodedString.length; offset += maxChunkLength) {
+    const chunk = encodedString.subarray(offset, offset + maxChunkLength);
+    decoder.writeChunk(chunk);
+  }
+  return decoder.toString();
+}
+class ChunkedAsciiDecoder {
+  str = "";
+  textDecoder = new TextDecoder("windows-1252");
+  writeChunk(chunk) {
+    const decodedChunk = this.textDecoder.decode(chunk, { stream: true });
+    this.str += decodedChunk;
+  }
+  toString() {
+    return this.str;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ChunkedAsciiDecoder,
+  decodeAscii,
+  encodeAscii,
+  encodeAsciiInto
+});

package/dist/encodings/Ascii.d.cts

@@ -0,0 +1,13 @@
+import { EncodeIntoResult } from './TextEncodingsCommon.cjs';
+
+declare function encodeAscii(asciiString: string): Uint8Array<ArrayBuffer>;
+declare function encodeAsciiInto(asciiString: string, resultBuffer: Uint8Array): EncodeIntoResult;
+declare function decodeAscii(encodedString: Uint8Array): string;
+declare class ChunkedAsciiDecoder {
+    private str;
+    private readonly textDecoder;
+    writeChunk(chunk: Uint8Array): void;
+    toString(): string;
+}
+
+export { ChunkedAsciiDecoder, decodeAscii, encodeAscii, encodeAsciiInto };

package/dist/encodings/Ascii.d.ts

@@ -0,0 +1,13 @@
+import { EncodeIntoResult } from './TextEncodingsCommon.js';
+
+declare function encodeAscii(asciiString: string): Uint8Array<ArrayBuffer>;
+declare function encodeAsciiInto(asciiString: string, resultBuffer: Uint8Array): EncodeIntoResult;
+declare function decodeAscii(encodedString: Uint8Array): string;
+declare class ChunkedAsciiDecoder {
+    private str;
+    private readonly textDecoder;
+    writeChunk(chunk: Uint8Array): void;
+    toString(): string;
+}
+
+export { ChunkedAsciiDecoder, decodeAscii, encodeAscii, encodeAsciiInto };

package/dist/encodings/Ascii.js

@@ -0,0 +1,48 @@
+function encodeAscii(asciiString) {
+  const charCount = asciiString.length;
+  const resultArray = new Uint8Array(charCount);
+  const { written } = encodeAsciiInto(asciiString, resultArray);
+  return resultArray.subarray(0, written);
+}
+function encodeAsciiInto(asciiString, resultBuffer) {
+  const len = asciiString.length;
+  if (resultBuffer.length < len) {
+    throw new Error(`Result Uint8Array is not large enough to hold the string`);
+  }
+  for (let readOffset = 0; readOffset < len; readOffset++) {
+    const charCode = asciiString.charCodeAt(readOffset);
+    if (charCode >= 128) {
+      throw new Error(
+        `Character '${asciiString[readOffset]}' (code: ${charCode}) can't be encoded as a standard ASCII character`
+      );
+    }
+    resultBuffer[readOffset] = charCode;
+  }
+  return { read: len, written: len };
+}
+function decodeAscii(encodedString) {
+  const maxChunkLength = 2 ** 24;
+  const decoder = new ChunkedAsciiDecoder();
+  for (let offset = 0; offset < encodedString.length; offset += maxChunkLength) {
+    const chunk = encodedString.subarray(offset, offset + maxChunkLength);
+    decoder.writeChunk(chunk);
+  }
+  return decoder.toString();
+}
+class ChunkedAsciiDecoder {
+  str = "";
+  textDecoder = new TextDecoder("windows-1252");
+  writeChunk(chunk) {
+    const decodedChunk = this.textDecoder.decode(chunk, { stream: true });
+    this.str += decodedChunk;
+  }
+  toString() {
+    return this.str;
+  }
+}
+export {
+  ChunkedAsciiDecoder,
+  decodeAscii,
+  encodeAscii,
+  encodeAsciiInto
+};