Skip to content

Voice-to-text dictation app with local (Nvidia Parakeet/Whisper) and cloud models (BYOK). Privacy-first and available cross-platform.

12.6 KB
Raw Blame
const test = require("node:test");
const assert = require("node:assert/strict");
const fs = require("node:fs/promises");
const Module = require("node:module");
const os = require("node:os");
const path = require("node:path");

const ParakeetManager = require("../../src/helpers/parakeet");
const WhisperManager = require("../../src/helpers/whisper");
const modelRegistryData = require("../../src/models/modelRegistryData.json");
const downloadUtils = require("../../src/helpers/downloadUtils");
const whisperModulePath = require.resolve("../../src/helpers/whisper");

function activeDownload(model, overrides = {}) {
  return {
    abort() {},
    model,
    phase: "progress",
    percentage: 42,
    downloadedBytes: 420,
    totalBytes: 1000,
    ...overrides,
  };
}

function stubMacosVersion(t, version) {
  const platformDescriptor = Object.getOwnPropertyDescriptor(process, "platform");
  const systemVersionDescriptor = Object.getOwnPropertyDescriptor(process, "getSystemVersion");

  Object.defineProperty(process, "platform", { configurable: true, value: "darwin" });
  Object.defineProperty(process, "getSystemVersion", {
    configurable: true,
    value: () => version,
  });

  t.after(() => {
    Object.defineProperty(process, "platform", platformDescriptor);
    if (systemVersionDescriptor) {
      Object.defineProperty(process, "getSystemVersion", systemVersionDescriptor);
    } else {
      delete process.getSystemVersion;
    }
  });
}

test("Parakeet reports its packaged runtime as unsupported on macOS below 15.5", async (t) => {
  stubMacosVersion(t, "12.7.6");
  const manager = new ParakeetManager();
  manager.serverManager.getBinaryPath = () => "/Applications/OpenWhispr.app/parakeet";

  const result = await manager.checkInstallation();

  assert.deepEqual(result, {
    installed: true,
    working: false,
    supported: false,
    code: "PARAKEET_UNSUPPORTED_OS",
    message:
      "Parakeet requires macOS 15.5 or later. Use cloud transcription (or Whisper where supported) on this Mac.",
    minimumMacOSVersion: "15.5",
  });
});

test("Parakeet refuses explicit server startup on unsupported macOS", async (t) => {
  stubMacosVersion(t, "12.7.6");
  const manager = new ParakeetManager();
  const model = Object.keys(modelRegistryData.parakeetModels)[0];
  let startCalls = 0;
  manager.serverManager.startServer = async () => {
    startCalls += 1;
    return { success: true };
  };

  const result = await manager.startServer(model);

  assert.deepEqual(result, {
    success: false,
    code: "PARAKEET_UNSUPPORTED_OS",
    reason:
      "Parakeet requires macOS 15.5 or later. Use cloud transcription (or Whisper where supported) on this Mac.",
  });
  assert.equal(startCalls, 0);
});

test("Parakeet refuses a missing-model download before filesystem or download setup", async (t) => {
  stubMacosVersion(t, "12.7.6");
  const manager = new ParakeetManager();
  const model = Object.keys(modelRegistryData.parakeetModels)[0];
  let modelStatusChecks = 0;
  let modelDirectoryChecks = 0;
  manager.serverManager.isModelDownloaded = () => {
    modelStatusChecks += 1;
    return false;
  };
  manager.getModelsDir = () => {
    modelDirectoryChecks += 1;
    throw new Error("unexpected model-directory access");
  };

  await assert.rejects(
    manager.downloadParakeetModel(model),
    (error) =>
      error.code === "PARAKEET_UNSUPPORTED_OS" &&
      error.message ===
        "Parakeet requires macOS 15.5 or later. Use cloud transcription (or Whisper where supported) on this Mac."
  );
  assert.equal(modelStatusChecks, 0);
  assert.equal(modelDirectoryChecks, 0);
});

test("Parakeet refuses streaming startup on unsupported macOS", async (t) => {
  stubMacosVersion(t, "12.7.6");
  const manager = new ParakeetManager();
  const model = Object.keys(modelRegistryData.parakeetModels).find((candidate) =>
    manager.supportsOnlineStreaming(candidate)
  );
  let startCalls = 0;
  manager.serverManager.startServer = async () => {
    startCalls += 1;
    return { success: true };
  };

  await assert.rejects(
    manager.createOnlineStream(model),
    (error) => error.code === "PARAKEET_UNSUPPORTED_OS"
  );
  assert.equal(startCalls, 0);
});

test("Parakeet refuses transcription before touching the sidecar on unsupported macOS", async (t) => {
  stubMacosVersion(t, "12.7.6");
  const manager = new ParakeetManager();
  const model = Object.keys(modelRegistryData.parakeetModels)[0];
  let transcribeCalls = 0;
  manager.serverManager.isAvailable = () => true;
  manager.serverManager.isModelDownloaded = () => true;
  manager.serverManager.transcribe = async () => {
    transcribeCalls += 1;
    return { text: "unexpected" };
  };

  await assert.rejects(
    manager.transcribeLocalParakeet(Buffer.from("audio"), { model }),
    (error) => error.code === "PARAKEET_UNSUPPORTED_OS"
  );
  assert.equal(transcribeCalls, 0);
});

test("Parakeet skips startup prewarming on unsupported macOS", async (t) => {
  stubMacosVersion(t, "12.7.6");
  const modelsDir = await fs.mkdtemp(path.join(os.tmpdir(), "openwhispr-parakeet-capability-"));
  t.after(() => fs.rm(modelsDir, { recursive: true, force: true }));
  const manager = new ParakeetManager();
  const model = Object.keys(modelRegistryData.parakeetModels)[0];
  let startCalls = 0;
  manager.getModelsDir = () => modelsDir;
  manager.logDependencyStatus = async () => {};
  manager.serverManager.isAvailable = () => true;
  manager.serverManager.isModelDownloaded = () => true;
  manager.serverManager.startServer = async () => {
    startCalls += 1;
    return { success: true };
  };

  await manager.initializeAtStartup({
    localTranscriptionProvider: "nvidia",
    parakeetModel: model,
  });

  assert.equal(startCalls, 0);
});

test("listParakeetModels surfaces active installation state", async () => {
  const manager = new ParakeetManager();
  const model = Object.keys(modelRegistryData.parakeetModels)[0];
  manager.serverManager.isModelDownloaded = () => false;
  manager.currentDownloadProcess = activeDownload(model, {
    phase: "installing",
    percentage: 100,
  });

  const result = await manager.listParakeetModels();
  const status = result.models.find((candidate) => candidate.model === model);

  assert.equal(status.downloaded, false);
  assert.equal(status.isDownloading, true);
  assert.equal(status.isInstalling, true);
  assert.equal(status.downloadProgress, 100);
  assert.equal(status.downloadedBytes, 420);
  assert.equal(status.totalBytes, 1000);
});

test("Parakeet rejects a duplicate download without replacing the active request", async () => {
  const manager = new ParakeetManager();
  const model = Object.keys(modelRegistryData.parakeetModels)[0];
  const active = activeDownload(model);
  manager.serverManager.isModelDownloaded = () => false;
  manager.currentDownloadProcess = active;

  await assert.rejects(
    manager.downloadParakeetModel(model),
    (error) => error.code === "DOWNLOAD_IN_PROGRESS" && error.details.activeModel === model
  );
  assert.equal(manager.currentDownloadProcess, active);
});

test("listWhisperModels surfaces active download state", async (t) => {
  const modelsDir = await fs.mkdtemp(path.join(os.tmpdir(), "openwhispr-whisper-status-"));
  t.after(() => fs.rm(modelsDir, { recursive: true, force: true }));

  const manager = new WhisperManager();
  const model = Object.keys(modelRegistryData.whisperModels)[0];
  manager.getModelsDir = () => modelsDir;
  manager.currentDownloadProcess = activeDownload(model);

  const result = await manager.listWhisperModels();
  const status = result.models.find((candidate) => candidate.model === model);

  assert.equal(status.downloaded, false);
  assert.equal(status.isDownloading, true);
  assert.equal(status.downloadProgress, 42);
  assert.equal(status.downloadedBytes, 420);
  assert.equal(status.totalBytes, 1000);
});

test("Whisper rejects a duplicate download without replacing the active request", async (t) => {
  const modelsDir = await fs.mkdtemp(path.join(os.tmpdir(), "openwhispr-whisper-guard-"));
  t.after(() => fs.rm(modelsDir, { recursive: true, force: true }));

  const manager = new WhisperManager();
  const model = Object.keys(modelRegistryData.whisperModels)[0];
  const active = activeDownload(model);
  manager.getModelsDir = () => modelsDir;
  manager.currentDownloadProcess = active;

  await assert.rejects(
    manager.downloadWhisperModel(model),
    (error) => error.code === "DOWNLOAD_IN_PROGRESS" && error.details.activeModel === model
  );
  assert.equal(manager.currentDownloadProcess, active);
});

test("Whisper emits a complete event after validating the downloaded model", async (t) => {
  const modelsDir = await fs.mkdtemp(path.join(os.tmpdir(), "openwhispr-whisper-complete-"));
  t.after(() => fs.rm(modelsDir, { recursive: true, force: true }));

  const originalLoad = Module._load;
  delete require.cache[whisperModulePath];
  Module._load = function loadWithDownloadMock(request, parent, isMain) {
    if (request === "./downloadUtils" && parent?.filename === whisperModulePath) {
      return {
        ...downloadUtils,
        checkDiskSpace: async () => ({ ok: true, availableBytes: Infinity }),
        downloadFile: async (_url, destination, options) => {
          await fs.writeFile(destination, Buffer.alloc(16));
          options.onProgress?.(16, 16);
          return destination;
        },
        validateFileSize: async () => 16,
      };
    }
    return originalLoad.call(this, request, parent, isMain);
  };

  let TestWhisperManager;
  try {
    TestWhisperManager = require("../../src/helpers/whisper");
  } finally {
    Module._load = originalLoad;
    delete require.cache[whisperModulePath];
  }

  const manager = new TestWhisperManager();
  const model = Object.keys(modelRegistryData.whisperModels)[0];
  const events = [];
  manager.getModelsDir = () => modelsDir;

  await manager.downloadWhisperModel(model, (event) => events.push(event));

  assert.equal(events.at(-1)?.type, "complete");
  assert.equal(events.at(-1)?.model, model);
  assert.equal(events.at(-1)?.percentage, 100);
});

test("cancellation keeps the download guard until the active request unwinds", async () => {
  const manager = new ParakeetManager();
  const model = Object.keys(modelRegistryData.parakeetModels)[0];
  let aborted = false;
  const active = activeDownload(model, {
    abort() {
      aborted = true;
    },
  });
  manager.currentDownloadProcess = active;

  const result = await manager.cancelDownload();

  assert.equal(result.success, true);
  assert.equal(aborted, true);
  assert.equal(manager.currentDownloadProcess, active);
});

test("Parakeet refuses cancellation after installation starts", async () => {
  const manager = new ParakeetManager();
  const model = Object.keys(modelRegistryData.parakeetModels)[0];
  let aborted = false;
  const active = activeDownload(model, {
    phase: "installing",
    abort() {
      aborted = true;
    },
  });
  manager.currentDownloadProcess = active;

  const result = await manager.cancelDownload();

  assert.equal(result.success, false);
  assert.equal(result.code, "INSTALLATION_IN_PROGRESS");
  assert.equal(aborted, false);
  assert.equal(manager.currentDownloadProcess, active);
});

test("an Orukeet directory without the sherpa ONNX files is not downloaded", async (t) => {
  const directory = await fs.mkdtemp(path.join(os.tmpdir(), "openwhispr-orukeet-layout-"));
  t.after(() => fs.rm(directory, { recursive: true, force: true }));
  const modelName = "orukeet-v0.1.0";
  const modelDirectory = path.join(directory, modelName);
  await fs.mkdir(modelDirectory);
  await fs.writeFile(path.join(modelDirectory, "orukeet-r3-93ce19c6-q8.gguf"), "old model");
  const manager = new ParakeetManager();
  manager.getModelsDir = () => directory;
  manager.serverManager.getModelsDir = () => directory;
  assert.equal((await manager.checkModelStatus(modelName)).downloaded, false);
  for (const file of ["encoder.int8.onnx", "decoder.int8.onnx", "joiner.int8.onnx"]) {
    await fs.writeFile(path.join(modelDirectory, file), "onnx fixture");
  }
  assert.equal((await manager.checkModelStatus(modelName)).downloaded, false);
  await fs.writeFile(path.join(modelDirectory, "tokens.txt"), "<blk> 0");
  assert.equal((await manager.checkModelStatus(modelName)).downloaded, true);
});

test("Orukeet inherits the packaged sherpa macOS floor before download or startup", async (t) => {
  stubMacosVersion(t, "14.8");
  const manager = new ParakeetManager();
  const modelName = "orukeet-v0.1.0";
  manager.getModelsDir = () => {
    throw new Error("unexpected filesystem access");
  };
  manager.serverManager.startServer = async () => {
    throw new Error("unexpected startup");
  };
  assert.equal((await manager.startServer(modelName)).code, "PARAKEET_UNSUPPORTED_OS");
  await assert.rejects(manager.downloadParakeetModel(modelName), {
    code: "PARAKEET_UNSUPPORTED_OS",
  });
});