Skip to content

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

fix(parakeet): Gate incompatible macOS runtime

Chadpiha0c271fefd5e9
diff --git a/.github/workflows/build-and-notarize.yml b/.github/workflows/build-and-notarize.yml
index 4c8bf6f40..a451fb4c8 100644
--- a/.github/workflows/build-and-notarize.yml
+++ b/.github/workflows/build-and-notarize.yml
@@ -375,6 +375,7 @@ jobs:
done
test -x "$APP_PATH/Contents/Resources/bin/MediaRemoteAdapter.framework/Versions/A/MediaRemoteAdapter" || { echo "Missing in bundle: MediaRemoteAdapter.framework"; exit 1; }
test -f "$APP_PATH/Contents/Resources/bin/mediaremote-adapter.pl" || { echo "Missing in bundle: mediaremote-adapter.pl"; exit 1; }
+ node scripts/verify-macos-parakeet.js "$APP_PATH"
- name: Upload Artifacts
uses: actions/upload-artifact@v4
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 15e34105d..38bd29e64 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -378,6 +378,7 @@ jobs:
for bin in macos-audio-tap macos-globe-listener macos-fast-paste macos-mic-listener macos-text-monitor macos-media-remote; do
test -x "$APP_PATH/Contents/Resources/bin/$bin" || { echo "Missing in bundle: $bin"; exit 1; }
done
+ node scripts/verify-macos-parakeet.js "$APP_PATH"
- name: Upload arch-specific update metadata
env:
diff --git a/scripts/download-sherpa-onnx.js b/scripts/download-sherpa-onnx.js
index 8778cef73..900ee5aec 100644
--- a/scripts/download-sherpa-onnx.js
+++ b/scripts/download-sherpa-onnx.js
@@ -9,6 +9,10 @@ const {
parseArgs,
setExecutable,
} = require("./lib/download-utils");
+const {
+ PARAKEET_MINIMUM_MACOS_VERSION,
+ compareVersions,
+} = require("../src/helpers/parakeetCapability");
const SHERPA_ONNX_VERSION = "1.13.4";
const GITHUB_RELEASE_URL = `https://github.com/k2-fsa/sherpa-onnx/releases/download/v${SHERPA_ONNX_VERSION}`;
@@ -62,6 +66,7 @@ const BINARIES = {
const BIN_DIR = path.join(__dirname, "..", "resources", "bin");
const VERSIONED_LIB_PATTERN = /^(lib.+?)\.(\d+\.\d+\.\d+)\.(dylib|so|dll)$/;
+const REQUIRED_MACOS_ARCHITECTURES = ["x86_64", "arm64"];
// Upstream 1.13.4 ships an invalid arm64 signature on libonnxruntime; dyld SIGKILLs unsigned loads.
function adhocSign(filePath, platformArch) {
@@ -73,6 +78,80 @@ function getDownloadUrl(archiveName) {
return `${GITHUB_RELEASE_URL}/${archiveName}`;
}
+function parseMacosDeploymentTargets(vtoolOutput) {
+ const targets = [];
+ let architecture = null;
+ let isMacosBuildVersion = false;
+
+ for (const line of String(vtoolOutput).split("\n")) {
+ const architectureMatch = line.match(/\(architecture ([^)]+)\):\s*$/);
+ if (architectureMatch) {
+ architecture = architectureMatch[1];
+ isMacosBuildVersion = false;
+ continue;
+ }
+
+ if (/^\s*platform MACOS\s*$/.test(line)) {
+ isMacosBuildVersion = true;
+ continue;
+ }
+
+ const minimumMatch = line.match(/^\s*minos (\S+)\s*$/);
+ if (architecture && isMacosBuildVersion && minimumMatch) {
+ targets.push({ architecture, minimumVersion: minimumMatch[1] });
+ isMacosBuildVersion = false;
+ }
+ }
+
+ return targets;
+}
+
+function validateMacosDeploymentTargets(targets) {
+ const architectures = new Set(targets.map((target) => target.architecture));
+ for (const architecture of REQUIRED_MACOS_ARCHITECTURES) {
+ if (!architectures.has(architecture)) {
+ throw new Error(`ONNX Runtime is missing required architecture: ${architecture}`);
+ }
+ }
+
+ for (const target of targets) {
+ if (compareVersions(target.minimumVersion, PARAKEET_MINIMUM_MACOS_VERSION) !== 0) {
+ throw new Error(
+ `${target.architecture} requires macOS ${target.minimumVersion}, but the Parakeet capability gate is ${PARAKEET_MINIMUM_MACOS_VERSION}`
+ );
+ }
+ }
+
+ return {
+ architectures: [...architectures],
+ minimumVersion: PARAKEET_MINIMUM_MACOS_VERSION,
+ };
+}
+
+function verifyPackagedMacosParakeet(
+ appPath,
+ {
+ readDirectory = fs.readdirSync,
+ runVtool = (libraryPath) =>
+ execFileSync("xcrun", ["vtool", "-show-build", libraryPath], { encoding: "utf8" }),
+ } = {}
+) {
+ const binDirectory = path.join(appPath, "Contents", "Resources", "bin");
+ const libraries = readDirectory(binDirectory).filter((fileName) =>
+ /^libonnxruntime\.\d+(?:\.\d+)*\.dylib$/.test(fileName)
+ );
+
+ if (libraries.length !== 1) {
+ throw new Error(
+ `Expected one versioned ONNX Runtime library in ${binDirectory}, found ${libraries.length}`
+ );
+ }
+
+ const libraryPath = path.join(binDirectory, libraries[0]);
+ const targets = parseMacosDeploymentTargets(runVtool(libraryPath));
+ return { ...validateMacosDeploymentTargets(targets), libraryPath };
+}
+
function extractTarBz2(archivePath, destDir) {
fs.mkdirSync(destDir, { recursive: true });
// Use relative paths from archive dir as cwd, so neither -f nor -C args
@@ -160,7 +239,10 @@ async function downloadBinary(platformArch, config, isForce = false) {
const diarizeOutputPath = path.join(BIN_DIR, config.diarizeOutputName);
const installMarkerPath = path.join(BIN_DIR, `.sherpa-onnx-${platformArch}.json`);
- if (!isForce && isCompleteInstall(installMarkerPath, [outputPath, onlineOutputPath, diarizeOutputPath])) {
+ if (
+ !isForce &&
+ isCompleteInstall(installMarkerPath, [outputPath, onlineOutputPath, diarizeOutputPath])
+ ) {
console.log(` ${platformArch}: Already exists (use --force to re-download)`);
return true;
}
@@ -316,6 +398,9 @@ module.exports = {
BINARIES,
BIN_DIR,
getDownloadUrl,
+ parseMacosDeploymentTargets,
+ validateMacosDeploymentTargets,
+ verifyPackagedMacosParakeet,
};
// Only run main() when executed directly
diff --git a/scripts/verify-macos-parakeet.js b/scripts/verify-macos-parakeet.js
new file mode 100644
index 000000000..486b14425
--- /dev/null
+++ b/scripts/verify-macos-parakeet.js
@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+const path = require("path");
+const { verifyPackagedMacosParakeet } = require("./download-sherpa-onnx");
+
+const appPath = process.argv[2];
+if (!appPath) {
+ console.error("Usage: node scripts/verify-macos-parakeet.js <OpenWhispr.app>");
+ process.exitCode = 1;
+} else {
+ try {
+ const result = verifyPackagedMacosParakeet(path.resolve(appPath));
+ console.log(
+ `Verified Parakeet ONNX Runtime for ${result.architectures.join(", ")} at macOS ${result.minimumVersion}`
+ );
+ } catch (error) {
+ console.error(`Parakeet compatibility validation failed: ${error.message}`);
+ process.exitCode = 1;
+ }
+}
diff --git a/src/components/TranscriptionModelPicker.tsx b/src/components/TranscriptionModelPicker.tsx
index 03d64483d..32ae74171 100644
--- a/src/components/TranscriptionModelPicker.tsx
+++ b/src/components/TranscriptionModelPicker.tsx
@@ -39,6 +39,7 @@ import { API_ENDPOINTS, normalizeBaseUrl } from "../config/constants";
import { GetApiKeyLink } from "./ui/GetApiKeyLink";
import { getCachedPlatform } from "../utils/platform";
import logger from "../utils/logger";
+import type { ParakeetCheckResult } from "../types/electron";
interface LocalModel {
model: string;
@@ -380,6 +381,7 @@ export default function TranscriptionModelPicker({
const effectiveLocal = mode === "local" ? true : mode === "cloud" ? false : useLocalWhisper;
const [localModels, setLocalModels] = useState<LocalModel[]>([]);
const [parakeetModels, setParakeetModels] = useState<LocalModel[]>([]);
+ const [parakeetCapability, setParakeetCapability] = useState<ParakeetCheckResult | null>(null);
const [internalLocalProvider, setInternalLocalProvider] = useState(selectedLocalProvider);
const hasLoadedRef = useRef(false);
const hasLoadedParakeetRef = useRef(false);
@@ -405,6 +407,30 @@ export default function TranscriptionModelPicker({
}
// eslint-disable-next-line react-hooks/exhaustive-deps -- sync prop→state: only re-run when the prop changes
}, [selectedLocalProvider]);
+
+ useEffect(() => {
+ let cancelled = false;
+
+ window.electronAPI
+ ?.checkParakeetInstallation?.()
+ .then((capability) => {
+ if (!cancelled) setParakeetCapability(capability);
+ })
+ .catch((error) => {
+ logger.error("Failed to check Parakeet compatibility", { error }, "models");
+ });
+
+ return () => {
+ cancelled = true;
+ };
+ }, []);
+
+ useEffect(() => {
+ if (parakeetCapability?.supported !== false || internalLocalProvider !== "nvidia") return;
+
+ setInternalLocalProvider("whisper");
+ onLocalProviderSelect?.("whisper");
+ }, [internalLocalProvider, onLocalProviderSelect, parakeetCapability]);
const localModelsLoadQueueRef = useRef<Promise<void>>(Promise.resolve());
const parakeetModelsLoadQueueRef = useRef<Promise<void>>(Promise.resolve());
const loadLocalModelsRef = useRef<(() => Promise<void>) | null>(null);
@@ -439,6 +465,21 @@ export default function TranscriptionModelPicker({
);
return filterByokProviderOptionsByPolicy(tabs, "transcription", policyState);
}, [availableCloudProviders, policyState, streamingOnly, t]);
+ const localProviderTabs = useMemo(
+ () =>
+ LOCAL_PROVIDER_TABS.map((provider) =>
+ provider.id === "nvidia" && parakeetCapability?.supported === false
+ ? {
+ ...provider,
+ disabled: true,
+ disabledLabel: parakeetCapability.minimumMacOSVersion
+ ? `macOS ${parakeetCapability.minimumMacOSVersion}+`
+ : "Unavailable",
+ }
+ : provider
+ ),
+ [parakeetCapability]
+ );
useEffect(() => {
selectedLocalModelRef.current = selectedLocalModel;
@@ -765,12 +806,12 @@ export default function TranscriptionModelPicker({
const handleLocalProviderChange = useCallback(
(providerId: string) => {
- const tab = LOCAL_PROVIDER_TABS.find((t) => t.id === providerId);
+ const tab = localProviderTabs.find((candidate) => candidate.id === providerId);
if (tab?.disabled) return;
setInternalLocalProvider(providerId);
onLocalProviderSelect?.(providerId);
},
- [onLocalProviderSelect]
+ [localProviderTabs, onLocalProviderSelect]
);
const handleWhisperModelSelect = useCallback(
@@ -1188,7 +1229,7 @@ export default function TranscriptionModelPicker({
) : (
<>
<ProviderTabs
- providers={LOCAL_PROVIDER_TABS}
+ providers={localProviderTabs}
selectedId={internalLocalProvider}
onSelect={handleLocalProviderChange}
colorScheme="purple"
diff --git a/src/helpers/ipcHandlers.js b/src/helpers/ipcHandlers.js
index 4de6743bc..214f8b666 100644
--- a/src/helpers/ipcHandlers.js
+++ b/src/helpers/ipcHandlers.js
@@ -4,6 +4,7 @@ const fs = require("fs");
const os = require("os");
const crypto = require("crypto");
const debugLogger = require("./debugLogger");
+const { PARAKEET_UNSUPPORTED_OS_CODE } = require("./parakeetCapability");
const { broadcastToWindows } = require("./windowBroadcast");
const { resolveFailedGpuBackends } = require("./whisper");
const { BYOK_API_KEYS } = require("../config/secretKeys");
@@ -2610,7 +2611,6 @@ class IPCHandlers {
message: errorMessage,
};
}
-
throw error;
}
});
@@ -2946,6 +2946,13 @@ class IPCHandlers {
message: errorMessage,
};
}
+ if (error.code === PARAKEET_UNSUPPORTED_OS_CODE) {
+ return {
+ success: false,
+ error: error.code,
+ message: errorMessage,
+ };
+ }
throw error;
}
diff --git a/src/helpers/parakeet.js b/src/helpers/parakeet.js
index a18d61c7b..81245fb8a 100644
--- a/src/helpers/parakeet.js
+++ b/src/helpers/parakeet.js
@@ -13,6 +13,7 @@ const {
} = require("./downloadUtils");
const ParakeetServerManager = require("./parakeetServer");
const { getModelsDirForService } = require("./modelDirUtils");
+const { assertParakeetSupported, getParakeetCapability } = require("./parakeetCapability");
const modelRegistryData = require("../models/modelRegistryData.json");
const { getModelRuntime, REQUIRED_MODEL_FILES } = require("./parakeetModelInfo");
@@ -70,8 +71,10 @@ class ParakeetManager {
await this.logDependencyStatus();
const { localTranscriptionProvider, parakeetModel } = settings;
+ const capability = getParakeetCapability();
if (
+ capability.supported &&
localTranscriptionProvider === "nvidia" &&
parakeetModel &&
this.serverManager.isAvailable(getModelRuntime(parakeetModel))
@@ -99,8 +102,9 @@ class ParakeetManager {
}
} else {
debugLogger.debug("Skipping parakeet server pre-warm", {
- reason:
- localTranscriptionProvider !== "nvidia"
+ reason: !capability.supported
+ ? capability.message
+ : localTranscriptionProvider !== "nvidia"
? "provider not nvidia"
: !parakeetModel
? "no model selected"
@@ -159,15 +163,29 @@ class ParakeetManager {
async checkInstallation() {
const binaryPath =
this.serverManager.getBinaryPath("offline") || this.serverManager.getBinaryPath("online");
+ const capability = getParakeetCapability();
+
+ if (!capability.supported) {
+ return {
+ installed: !!binaryPath,
+ working: false,
+ ...capability,
+ };
+ }
+
if (!binaryPath) {
- return { installed: false, working: false };
+ return { installed: false, working: false, supported: true };
}
- return { installed: true, working: true, path: binaryPath };
+ return { installed: true, working: true, supported: true, path: binaryPath };
}
async startServer(modelName) {
this.validateModelName(modelName);
+ const capability = getParakeetCapability();
+ if (!capability.supported) {
+ return { success: false, code: capability.code, reason: capability.message };
+ }
return this.serverManager.startServer(modelName);
}
@@ -185,6 +203,7 @@ class ParakeetManager {
async createOnlineStream(modelName, options = {}) {
this.validateModelName(modelName);
+ assertParakeetSupported();
const started = await this.serverManager.startServer(modelName);
if (!started.success) {
throw new Error(started.reason || "Failed to start parakeet streaming server");
@@ -194,6 +213,7 @@ class ParakeetManager {
async transcribeLocalParakeet(audioBlob, options = {}) {
const model = options.model || "parakeet-tdt-0.6b-v3";
+ assertParakeetSupported();
const serverAvailable = this.serverManager.isAvailable(getModelRuntime(model));
debugLogger.logSTTPipeline("transcribeLocalParakeet - start", {
@@ -282,6 +302,7 @@ class ParakeetManager {
async downloadParakeetModel(modelName, progressCallback = null) {
this.validateModelName(modelName);
+ assertParakeetSupported();
const modelConfig = getParakeetModelConfig(modelName);
const modelPath = this.getModelPath(modelName);
diff --git a/src/helpers/parakeetCapability.js b/src/helpers/parakeetCapability.js
new file mode 100644
index 000000000..136d53a7e
--- /dev/null
+++ b/src/helpers/parakeetCapability.js
@@ -0,0 +1,54 @@
+const PARAKEET_MINIMUM_MACOS_VERSION = "15.5";
+const PARAKEET_UNSUPPORTED_OS_CODE = "PARAKEET_UNSUPPORTED_OS";
+
+function compareVersions(left, right) {
+ const leftParts = String(left).split(".").map(Number);
+ const rightParts = String(right).split(".").map(Number);
+ const length = Math.max(leftParts.length, rightParts.length);
+
+ for (let index = 0; index < length; index += 1) {
+ const difference = (leftParts[index] || 0) - (rightParts[index] || 0);
+ if (difference !== 0) return difference > 0 ? 1 : -1;
+ }
+
+ return 0;
+}
+
+function getParakeetCapability({ platform = process.platform, systemVersion } = {}) {
+ if (platform !== "darwin") return { supported: true };
+
+ const detectedVersion =
+ systemVersion ??
+ (typeof process.getSystemVersion === "function" ? process.getSystemVersion() : null);
+
+ // Plain Node does not expose Electron's system-version API. Production main-process
+ // calls always provide it; allowing Node keeps build tooling and unit tests portable.
+ if (!detectedVersion || compareVersions(detectedVersion, PARAKEET_MINIMUM_MACOS_VERSION) >= 0) {
+ return { supported: true };
+ }
+
+ return {
+ supported: false,
+ code: PARAKEET_UNSUPPORTED_OS_CODE,
+ message: `Parakeet requires macOS ${PARAKEET_MINIMUM_MACOS_VERSION} or later. Use Whisper or cloud transcription on this Mac.`,
+ minimumMacOSVersion: PARAKEET_MINIMUM_MACOS_VERSION,
+ };
+}
+
+function assertParakeetSupported(options) {
+ const capability = getParakeetCapability(options);
+ if (capability.supported) return;
+
+ throw Object.assign(new Error(capability.message), {
+ code: capability.code,
+ minimumMacOSVersion: capability.minimumMacOSVersion,
+ });
+}
+
+module.exports = {
+ PARAKEET_MINIMUM_MACOS_VERSION,
+ PARAKEET_UNSUPPORTED_OS_CODE,
+ compareVersions,
+ getParakeetCapability,
+ assertParakeetSupported,
+};
diff --git a/src/types/electron.ts b/src/types/electron.ts
index e94699d18..21f2dfd72 100644
--- a/src/types/electron.ts
+++ b/src/types/electron.ts
@@ -667,7 +667,11 @@ export interface WhisperDownloadProgressData {
export interface ParakeetCheckResult {
installed: boolean;
working: boolean;
+ supported?: boolean;
path?: string;
+ code?: string;
+ message?: string;
+ minimumMacOSVersion?: string;
}
export interface ParakeetModelResult {
diff --git a/test/helpers/parakeetCapability.test.js b/test/helpers/parakeetCapability.test.js
new file mode 100644
index 000000000..b89dc1c0a
--- /dev/null
+++ b/test/helpers/parakeetCapability.test.js
@@ -0,0 +1,31 @@
+const test = require("node:test");
+const assert = require("node:assert/strict");
+
+const { getParakeetCapability } = require("../../src/helpers/parakeetCapability");
+
+test("Parakeet supports macOS at and above the packaged ONNX Runtime floor", () => {
+ assert.deepEqual(getParakeetCapability({ platform: "darwin", systemVersion: "15.5" }), {
+ supported: true,
+ });
+ assert.deepEqual(getParakeetCapability({ platform: "darwin", systemVersion: "15.6.1" }), {
+ supported: true,
+ });
+});
+
+test("Parakeet rejects macOS below the packaged ONNX Runtime floor", () => {
+ assert.deepEqual(getParakeetCapability({ platform: "darwin", systemVersion: "12.7.6" }), {
+ supported: false,
+ code: "PARAKEET_UNSUPPORTED_OS",
+ message:
+ "Parakeet requires macOS 15.5 or later. Use Whisper or cloud transcription on this Mac.",
+ minimumMacOSVersion: "15.5",
+ });
+});
+
+test("Parakeet capability gating does not change Windows or Linux", () => {
+ for (const platform of ["win32", "linux"]) {
+ assert.deepEqual(getParakeetCapability({ platform, systemVersion: "1.0" }), {
+ supported: true,
+ });
+ }
+});
diff --git a/test/helpers/parakeetDeploymentTarget.test.js b/test/helpers/parakeetDeploymentTarget.test.js
new file mode 100644
index 000000000..9f1fa0c7b
--- /dev/null
+++ b/test/helpers/parakeetDeploymentTarget.test.js
@@ -0,0 +1,81 @@
+const test = require("node:test");
+const assert = require("node:assert/strict");
+
+const sherpaDownloader = require("../../scripts/download-sherpa-onnx");
+
+const UNIVERSAL_VTOOL_OUTPUT = `
+/tmp/libonnxruntime.1.27.0.dylib (architecture x86_64):
+Load command 10
+ cmd LC_BUILD_VERSION
+ platform MACOS
+ minos 15.5
+ sdk 15.5
+/tmp/libonnxruntime.1.27.0.dylib (architecture arm64):
+Load command 10
+ cmd LC_BUILD_VERSION
+ platform MACOS
+ minos 15.5
+ sdk 15.5
+`;
+
+test("parses deployment targets for both ONNX Runtime architecture slices", () => {
+ const targets = sherpaDownloader.parseMacosDeploymentTargets?.(UNIVERSAL_VTOOL_OUTPUT);
+
+ assert.deepEqual(targets, [
+ { architecture: "x86_64", minimumVersion: "15.5" },
+ { architecture: "arm64", minimumVersion: "15.5" },
+ ]);
+});
+
+test("accepts a universal ONNX Runtime library matching the runtime capability gate", () => {
+ const result = sherpaDownloader.validateMacosDeploymentTargets?.([
+ { architecture: "x86_64", minimumVersion: "15.5" },
+ { architecture: "arm64", minimumVersion: "15.5" },
+ ]);
+
+ assert.deepEqual(result, {
+ architectures: ["x86_64", "arm64"],
+ minimumVersion: "15.5",
+ });
+});
+
+test("rejects an ONNX Runtime slice whose deployment target exceeds the runtime gate", () => {
+ assert.throws(
+ () =>
+ sherpaDownloader.validateMacosDeploymentTargets([
+ { architecture: "x86_64", minimumVersion: "15.5" },
+ { architecture: "arm64", minimumVersion: "16.0" },
+ ]),
+ /arm64 requires macOS 16.0, but the Parakeet capability gate is 15.5/
+ );
+});
+
+test("rejects a packaged ONNX Runtime library missing a universal architecture slice", () => {
+ assert.throws(
+ () =>
+ sherpaDownloader.validateMacosDeploymentTargets([
+ { architecture: "arm64", minimumVersion: "15.5" },
+ ]),
+ /missing required architecture: x86_64/
+ );
+});
+
+test("validates the versioned ONNX Runtime library from a packaged app", () => {
+ const appPath = "/tmp/OpenWhispr.app";
+ const result = sherpaDownloader.verifyPackagedMacosParakeet?.(appPath, {
+ readDirectory(directory) {
+ assert.equal(directory, `${appPath}/Contents/Resources/bin`);
+ return ["libonnxruntime.dylib", "libonnxruntime.1.27.0.dylib"];
+ },
+ runVtool(libraryPath) {
+ assert.equal(libraryPath, `${appPath}/Contents/Resources/bin/libonnxruntime.1.27.0.dylib`);
+ return UNIVERSAL_VTOOL_OUTPUT;
+ },
+ });
+
+ assert.deepEqual(result, {
+ architectures: ["x86_64", "arm64"],
+ libraryPath: `${appPath}/Contents/Resources/bin/libonnxruntime.1.27.0.dylib`,
+ minimumVersion: "15.5",
+ });
+});
diff --git a/test/helpers/transcriptionModelDownloadStatus.test.js b/test/helpers/transcriptionModelDownloadStatus.test.js
index 6fc276abc..4f49e0174 100644
--- a/test/helpers/transcriptionModelDownloadStatus.test.js
+++ b/test/helpers/transcriptionModelDownloadStatus.test.js
@@ -23,6 +23,153 @@ function activeDownload(model, 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 Whisper or cloud transcription 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 Whisper or cloud transcription 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 Whisper or cloud transcription 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];