@storyteller-platform/ghost-story 0.0.1

package/dist/audio/AudioConverter.js

@@ -0,0 +1,310 @@
+import { execFile } from "node:child_process";
+import { createReadStream, createWriteStream } from "node:fs";
+import { rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { pipeline } from "node:stream/promises";
+import { promisify } from "node:util";
+import { Converter } from "ffmpeg-stream";
+const execFilePromisified = promisify(execFile);
+async function execFileAsync(cmd, args) {
+  return execFilePromisified(cmd, args);
+}
+import { getConversionMode } from "../config.js";
+import {
+  formatToExtension,
+  getTargetFormat,
+  needsConversion,
+  serviceCapabilities
+} from "./AudioFormat.js";
+import {
+  audioSourceFromBuffer,
+  audioSourceFromFile,
+  toFilePath,
+  toReadStream
+} from "./AudioSource.js";
+function getFFmpegFormatOptions(format, sampleRate, channels) {
+  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 (sampleRate) {
+    opts["ar"] = String(sampleRate);
+  }
+  if (channels) {
+    opts["ac"] = String(channels);
+  }
+  return opts;
+}
+function getFFmpegInputFormat(format) {
+  switch (format) {
+    case "pcm":
+      return { f: "s16le", ar: "16000", ac: "1" };
+    default:
+      return {};
+  }
+}
+async function convertToFile(source, options) {
+  const tempPath = join(
+    tmpdir(),
+    `audio-convert-${Date.now()}${formatToExtension(options.targetFormat)}`
+  );
+  const converter = new Converter();
+  const inputPath = toFilePath(source);
+  if (inputPath) {
+    converter.createInputFromFile(inputPath);
+  } else {
+    const inputOpts = getFFmpegInputFormat(source.format);
+    const inputStream = converter.createInputStream(inputOpts);
+    const readable = toReadStream(source);
+    readable.pipe(inputStream);
+  }
+  const outputOpts = getFFmpegFormatOptions(
+    options.targetFormat,
+    options.sampleRate,
+    options.channels
+  );
+  converter.createOutputToFile(tempPath, outputOpts);
+  await converter.run();
+  return {
+    source: audioSourceFromFile(tempPath, options.targetFormat),
+    cleanup: async () => {
+      await rm(tempPath, { force: true }).catch(() => {
+      });
+    }
+  };
+}
+async function convertToBuffer(source, options) {
+  const converter = new Converter();
+  const inputPath = toFilePath(source);
+  if (inputPath) {
+    converter.createInputFromFile(inputPath);
+  } else {
+    const inputOpts = getFFmpegInputFormat(source.format);
+    const inputStream = converter.createInputStream(inputOpts);
+    const readable = toReadStream(source);
+    readable.pipe(inputStream);
+  }
+  const outputOpts = getFFmpegFormatOptions(
+    options.targetFormat,
+    options.sampleRate,
+    options.channels
+  );
+  const outputStream = converter.createOutputStream(outputOpts);
+  const chunks = [];
+  outputStream.on("data", (chunk) => chunks.push(chunk));
+  const bufferPromise = new Promise((resolve, reject) => {
+    outputStream.on("end", () => {
+      resolve(Buffer.concat(chunks));
+    });
+    outputStream.on("error", reject);
+  });
+  await converter.run();
+  const buffer = await bufferPromise;
+  return {
+    source: audioSourceFromBuffer(buffer, options.targetFormat),
+    cleanup: async () => {
+    }
+  };
+}
+function convertToStream(source, options) {
+  const converter = new Converter();
+  const inputPath = toFilePath(source);
+  if (inputPath) {
+    converter.createInputFromFile(inputPath);
+  } else {
+    const inputOpts = getFFmpegInputFormat(source.format);
+    const inputStream = converter.createInputStream(inputOpts);
+    const readable = toReadStream(source);
+    readable.pipe(inputStream);
+  }
+  const outputOpts = getFFmpegFormatOptions(
+    options.targetFormat,
+    options.sampleRate,
+    options.channels
+  );
+  const outputStream = converter.createOutputStream(outputOpts);
+  return {
+    stream: outputStream,
+    runConversion: () => converter.run()
+  };
+}
+async function prepareForService(source, options) {
+  const caps = serviceCapabilities[options.service];
+  if (!caps) {
+    throw new Error(`Unknown service: ${options.service}`);
+  }
+  const inputFormat = source.format;
+  const requiresConversion = needsConversion(inputFormat, options.service);
+  const targetFormat = getTargetFormat(inputFormat, options.service);
+  if (!requiresConversion) {
+    if (caps.requiresFile && source.type !== "file") {
+      return writeToTempFile(source);
+    }
+    return { source, cleanup: async () => {
+    } };
+  }
+  const conversionOptions = {
+    targetFormat,
+    sampleRate: caps.preferredSampleRate,
+    channels: caps.preferredChannels
+  };
+  if (caps.requiresFile || options.preferFile) {
+    return convertToFile(source, conversionOptions);
+  }
+  if (caps.requiresBase64) {
+    return convertToBuffer(source, conversionOptions);
+  }
+  return convertToFile(source, conversionOptions);
+}
+async function writeToTempFile(source) {
+  const tempPath = join(
+    tmpdir(),
+    `audio-temp-${Date.now()}${formatToExtension(source.format)}`
+  );
+  const readable = toReadStream(source);
+  const writable = createWriteStream(tempPath);
+  await pipeline(readable, writable);
+  return {
+    source: audioSourceFromFile(tempPath, source.format),
+    cleanup: async () => {
+      await rm(tempPath, { force: true }).catch(() => {
+      });
+    }
+  };
+}
+async function prepareWavForService(source, options = {}) {
+  if (source.format === "wav" && source.type === "file") {
+    return { source, cleanup: async () => {
+    } };
+  }
+  return convertToFile(source, {
+    targetFormat: "wav",
+    sampleRate: options.sampleRate ?? 16e3,
+    channels: options.channels ?? 1
+  });
+}
+function createStreamingConversion(source, options) {
+  const { stream, runConversion } = convertToStream(source, options);
+  return { stream, start: runConversion };
+}
+async function createStreamForUpload(options) {
+  const mode = options.mode ?? getConversionMode();
+  const needsConvert = options.source.format !== options.targetFormat;
+  if (!needsConvert) {
+    const stream = toReadStream(options.source);
+    return {
+      stream,
+      format: options.source.format,
+      cleanup: async () => {
+      },
+      mode
+    };
+  }
+  if (mode === "file-first") {
+    const tempPath = join(
+      tmpdir(),
+      `upload-${Date.now()}${formatToExtension(options.targetFormat)}`
+    );
+    const converter2 = new Converter();
+    const inputPath2 = toFilePath(options.source);
+    if (inputPath2) {
+      converter2.createInputFromFile(inputPath2);
+    } else {
+      const inputOpts = getFFmpegInputFormat(options.source.format);
+      const inputStream = converter2.createInputStream(inputOpts);
+      const readable = toReadStream(options.source);
+      readable.pipe(inputStream);
+    }
+    const outputOpts2 = getFFmpegFormatOptions(
+      options.targetFormat,
+      options.sampleRate,
+      options.channels
+    );
+    converter2.createOutputToFile(tempPath, outputOpts2);
+    await converter2.run();
+    const stream = createReadStream(tempPath);
+    return {
+      stream,
+      format: options.targetFormat,
+      cleanup: async () => {
+        await rm(tempPath, { force: true }).catch(() => {
+        });
+      },
+      mode
+    };
+  }
+  const converter = new Converter();
+  const inputPath = toFilePath(options.source);
+  if (inputPath) {
+    converter.createInputFromFile(inputPath);
+  } else {
+    const inputOpts = getFFmpegInputFormat(options.source.format);
+    const inputStream = converter.createInputStream(inputOpts);
+    const readable = toReadStream(options.source);
+    readable.pipe(inputStream);
+  }
+  const outputOpts = getFFmpegFormatOptions(
+    options.targetFormat,
+    options.sampleRate,
+    options.channels
+  );
+  const outputStream = converter.createOutputStream(outputOpts);
+  return {
+    stream: outputStream,
+    format: options.targetFormat,
+    cleanup: async () => {
+    },
+    start: () => converter.run(),
+    mode
+  };
+}
+async function getAudioDuration(filePath) {
+  const { stdout } = await execFileAsync("ffprobe", [
+    "-v",
+    "quiet",
+    "-show_entries",
+    "format=duration",
+    "-of",
+    "default=noprint_wrappers=1:nokey=1",
+    filePath
+  ]);
+  const duration = parseFloat(stdout.trim());
+  if (Number.isNaN(duration)) {
+    throw new Error(
+      `Failed to parse audio duration from ffprobe output: ${stdout}`
+    );
+  }
+  return duration;
+}
+export {
+  convertToBuffer,
+  convertToFile,
+  convertToStream,
+  createStreamForUpload,
+  createStreamingConversion,
+  getAudioDuration,
+  prepareForService,
+  prepareWavForService
+};

package/dist/audio/AudioFormat.cjs

@@ -0,0 +1,151 @@
+"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 AudioFormat_exports = {};
+__export(AudioFormat_exports, {
+  formatFromExtension: () => formatFromExtension,
+  formatToExtension: () => formatToExtension,
+  getTargetFormat: () => getTargetFormat,
+  needsConversion: () => needsConversion,
+  serviceCapabilities: () => serviceCapabilities
+});
+module.exports = __toCommonJS(AudioFormat_exports);
+var import_node_path = require("node:path");
+const extensionToFormat = {
+  ".wav": "wav",
+  ".wave": "wav",
+  ".flac": "flac",
+  ".opus": "opus",
+  ".ogg": "ogg",
+  ".mp3": "mp3",
+  ".webm": "webm",
+  ".m4a": "m4a",
+  ".aac": "aac",
+  ".pcm": "pcm",
+  ".mp4": "mp4"
+};
+function formatFromExtension(filepath) {
+  const ext = (0, import_node_path.extname)(filepath).toLowerCase();
+  return extensionToFormat[ext] ?? null;
+}
+function formatToExtension(format) {
+  switch (format) {
+    case "wav":
+      return ".wav";
+    case "flac":
+      return ".flac";
+    case "opus":
+      return ".opus";
+    case "ogg":
+      return ".ogg";
+    case "mp3":
+      return ".mp3";
+    case "webm":
+      return ".webm";
+    case "m4a":
+      return ".m4a";
+    case "aac":
+      return ".aac";
+    case "pcm":
+      return ".pcm";
+    case "mp4":
+      return ".mp4";
+    default:
+      return ".unknown";
+  }
+}
+const serviceCapabilities = {
+  "whisper.cpp": {
+    acceptsFormats: ["wav", "flac", "ogg", "mp3"],
+    preferredFormat: "wav",
+    requiresFile: true,
+    supportsStreaming: false,
+    requiresBase64: false,
+    preferredSampleRate: 16e3,
+    preferredChannels: 1
+  },
+  "whisper-server": {
+    acceptsFormats: ["wav", "flac", "ogg", "mp3"],
+    preferredFormat: "wav",
+    requiresFile: true,
+    supportsStreaming: false,
+    requiresBase64: false,
+    preferredSampleRate: 16e3,
+    preferredChannels: 1
+  },
+  "openai-cloud": {
+    acceptsFormats: ["wav", "flac", "mp3", "m4a", "ogg", "webm"],
+    preferredFormat: "mp3",
+    requiresFile: false,
+    supportsStreaming: true,
+    requiresBase64: false
+  },
+  "google-cloud": {
+    acceptsFormats: ["wav", "flac", "mp3", "ogg", "opus", "webm"],
+    preferredFormat: "flac",
+    requiresFile: false,
+    supportsStreaming: false,
+    requiresBase64: true,
+    preferredSampleRate: 16e3,
+    preferredChannels: 1
+  },
+  "microsoft-azure": {
+    acceptsFormats: ["wav"],
+    preferredFormat: "wav",
+    requiresFile: false,
+    supportsStreaming: true,
+    requiresBase64: false,
+    preferredSampleRate: 16e3,
+    preferredChannels: 1
+  },
+  "amazon-transcribe": {
+    acceptsFormats: ["flac", "opus", "ogg"],
+    preferredFormat: "flac",
+    requiresFile: false,
+    supportsStreaming: true,
+    requiresBase64: false,
+    preferredSampleRate: 16e3,
+    preferredChannels: 1
+  },
+  deepgram: {
+    acceptsFormats: ["wav", "flac", "mp3", "opus", "ogg", "webm", "m4a"],
+    preferredFormat: "wav",
+    requiresFile: false,
+    supportsStreaming: true,
+    requiresBase64: false
+  }
+};
+function needsConversion(inputFormat, service) {
+  const caps = serviceCapabilities[service];
+  if (!caps) return true;
+  return !caps.acceptsFormats.includes(inputFormat);
+}
+function getTargetFormat(inputFormat, service) {
+  const caps = serviceCapabilities[service];
+  if (!caps) return "wav";
+  if (caps.acceptsFormats.includes(inputFormat)) return inputFormat;
+  return caps.preferredFormat;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  formatFromExtension,
+  formatToExtension,
+  getTargetFormat,
+  needsConversion,
+  serviceCapabilities
+});

package/dist/audio/AudioFormat.d.cts

@@ -0,0 +1,25 @@
+type AudioFormat = "unknown" | "wav" | "flac" | "opus" | "ogg" | "mp3" | "webm" | "m4a" | "aac" | "pcm" | "mp4";
+type AudioEncoding = "pcm_s16le" | "flac" | "opus" | "mp3" | "aac";
+interface AudioFormatInfo {
+    format: AudioFormat;
+    sampleRate?: number;
+    channels?: number;
+    bitDepth?: number;
+}
+declare function formatFromExtension(filepath: string): AudioFormat | null;
+declare function formatToExtension(format: AudioFormat): string;
+interface ServiceCapabilities {
+    acceptsFormats: AudioFormat[];
+    preferredFormat: AudioFormat;
+    requiresFile: boolean;
+    supportsStreaming: boolean;
+    requiresBase64: boolean;
+    maxSampleRate?: number;
+    preferredSampleRate?: number;
+    preferredChannels?: number;
+}
+declare const serviceCapabilities: Record<string, ServiceCapabilities>;
+declare function needsConversion(inputFormat: AudioFormat, service: string): boolean;
+declare function getTargetFormat(inputFormat: AudioFormat, service: string): AudioFormat;
+
+export { type AudioEncoding, type AudioFormat, type AudioFormatInfo, type ServiceCapabilities, formatFromExtension, formatToExtension, getTargetFormat, needsConversion, serviceCapabilities };

package/dist/audio/AudioFormat.d.ts

@@ -0,0 +1,25 @@
+type AudioFormat = "unknown" | "wav" | "flac" | "opus" | "ogg" | "mp3" | "webm" | "m4a" | "aac" | "pcm" | "mp4";
+type AudioEncoding = "pcm_s16le" | "flac" | "opus" | "mp3" | "aac";
+interface AudioFormatInfo {
+    format: AudioFormat;
+    sampleRate?: number;
+    channels?: number;
+    bitDepth?: number;
+}
+declare function formatFromExtension(filepath: string): AudioFormat | null;
+declare function formatToExtension(format: AudioFormat): string;
+interface ServiceCapabilities {
+    acceptsFormats: AudioFormat[];
+    preferredFormat: AudioFormat;
+    requiresFile: boolean;
+    supportsStreaming: boolean;
+    requiresBase64: boolean;
+    maxSampleRate?: number;
+    preferredSampleRate?: number;
+    preferredChannels?: number;
+}
+declare const serviceCapabilities: Record<string, ServiceCapabilities>;
+declare function needsConversion(inputFormat: AudioFormat, service: string): boolean;
+declare function getTargetFormat(inputFormat: AudioFormat, service: string): AudioFormat;
+
+export { type AudioEncoding, type AudioFormat, type AudioFormatInfo, type ServiceCapabilities, formatFromExtension, formatToExtension, getTargetFormat, needsConversion, serviceCapabilities };

package/dist/audio/AudioFormat.js

@@ -0,0 +1,123 @@
+import { extname } from "node:path";
+const extensionToFormat = {
+  ".wav": "wav",
+  ".wave": "wav",
+  ".flac": "flac",
+  ".opus": "opus",
+  ".ogg": "ogg",
+  ".mp3": "mp3",
+  ".webm": "webm",
+  ".m4a": "m4a",
+  ".aac": "aac",
+  ".pcm": "pcm",
+  ".mp4": "mp4"
+};
+function formatFromExtension(filepath) {
+  const ext = extname(filepath).toLowerCase();
+  return extensionToFormat[ext] ?? null;
+}
+function formatToExtension(format) {
+  switch (format) {
+    case "wav":
+      return ".wav";
+    case "flac":
+      return ".flac";
+    case "opus":
+      return ".opus";
+    case "ogg":
+      return ".ogg";
+    case "mp3":
+      return ".mp3";
+    case "webm":
+      return ".webm";
+    case "m4a":
+      return ".m4a";
+    case "aac":
+      return ".aac";
+    case "pcm":
+      return ".pcm";
+    case "mp4":
+      return ".mp4";
+    default:
+      return ".unknown";
+  }
+}
+const serviceCapabilities = {
+  "whisper.cpp": {
+    acceptsFormats: ["wav", "flac", "ogg", "mp3"],
+    preferredFormat: "wav",
+    requiresFile: true,
+    supportsStreaming: false,
+    requiresBase64: false,
+    preferredSampleRate: 16e3,
+    preferredChannels: 1
+  },
+  "whisper-server": {
+    acceptsFormats: ["wav", "flac", "ogg", "mp3"],
+    preferredFormat: "wav",
+    requiresFile: true,
+    supportsStreaming: false,
+    requiresBase64: false,
+    preferredSampleRate: 16e3,
+    preferredChannels: 1
+  },
+  "openai-cloud": {
+    acceptsFormats: ["wav", "flac", "mp3", "m4a", "ogg", "webm"],
+    preferredFormat: "mp3",
+    requiresFile: false,
+    supportsStreaming: true,
+    requiresBase64: false
+  },
+  "google-cloud": {
+    acceptsFormats: ["wav", "flac", "mp3", "ogg", "opus", "webm"],
+    preferredFormat: "flac",
+    requiresFile: false,
+    supportsStreaming: false,
+    requiresBase64: true,
+    preferredSampleRate: 16e3,
+    preferredChannels: 1
+  },
+  "microsoft-azure": {
+    acceptsFormats: ["wav"],
+    preferredFormat: "wav",
+    requiresFile: false,
+    supportsStreaming: true,
+    requiresBase64: false,
+    preferredSampleRate: 16e3,
+    preferredChannels: 1
+  },
+  "amazon-transcribe": {
+    acceptsFormats: ["flac", "opus", "ogg"],
+    preferredFormat: "flac",
+    requiresFile: false,
+    supportsStreaming: true,
+    requiresBase64: false,
+    preferredSampleRate: 16e3,
+    preferredChannels: 1
+  },
+  deepgram: {
+    acceptsFormats: ["wav", "flac", "mp3", "opus", "ogg", "webm", "m4a"],
+    preferredFormat: "wav",
+    requiresFile: false,
+    supportsStreaming: true,
+    requiresBase64: false
+  }
+};
+function needsConversion(inputFormat, service) {
+  const caps = serviceCapabilities[service];
+  if (!caps) return true;
+  return !caps.acceptsFormats.includes(inputFormat);
+}
+function getTargetFormat(inputFormat, service) {
+  const caps = serviceCapabilities[service];
+  if (!caps) return "wav";
+  if (caps.acceptsFormats.includes(inputFormat)) return inputFormat;
+  return caps.preferredFormat;
+}
+export {
+  formatFromExtension,
+  formatToExtension,
+  getTargetFormat,
+  needsConversion,
+  serviceCapabilities
+};