Voice-to-text dictation app with local (Nvidia Parakeet/Whisper) and cloud models (BYOK). Privacy-first and available cross-platform.
JavaScript aianthropiccross-platformgeminigroqlinuxmacosnvidiaopen-sourceopenaiparakeetspeech-to-texttranscribewhisperwindows
const assert = require("node:assert/strict");
const test = require("node:test");
const React = require("react");
const { createRoot } = require("react-dom/client");
const {
createRendererServer,
installBrowserGlobals,
installHookDom,
} = require("../lib/rendererTestHarness");
const FIRST_LLM = "qwen3.5-4b-q4_k_m";
const SECOND_LLM = "qwen3.5-2b-q4_k_m";
const PARAKEET = "parakeet-tdt-0.6b-v3";
function findElement(node, predicate) {
if (Array.isArray(node)) {
for (const child of node) {
const match = findElement(child, predicate);
if (match) return match;
}
return null;
}
if (!node || typeof node !== "object") return null;
return predicate(node) ? node : findElement(node.props?.children, predicate);
}
function textContent(node) {
if (Array.isArray(node)) return node.map(textContent).join("");
if (node && typeof node === "object") return textContent(node.props?.children);
return node == null || typeof node === "boolean" ? "" : String(node);
}
async function createSetupHarness(
t,
{
assistant = false,
provider = assistant ? "qwen" : "whisper",
installed = {},
selectedModel = "",
resumeState,
capability = { supported: true },
freshInstall = false,
} = {}
) {
let unmount = async () => {};
t.after(() => unmount());
const listeners = { whisper: new Set(), parakeet: new Set(), llm: new Set() };
const inventory = {
whisper: new Set(installed.whisper),
parakeet: new Set(installed.parakeet),
llm: new Set(installed.llm),
};
const requests = new Map();
const events = new EventTarget();
const subscribe = (family) => (listener) => {
listeners[family].add(listener);
return () => listeners[family].delete(listener);
};
const startDownload = (family) => (modelId) =>
new Promise((resolve) => requests.set(modelId, { family, resolve }));
installBrowserGlobals(t, {
window: {
addEventListener: events.addEventListener.bind(events),
removeEventListener: events.removeEventListener.bind(events),
dispatchEvent: events.dispatchEvent.bind(events),
electronAPI: {
getPlatform: () => "linux",
checkParakeetInstallation: async () => capability,
listWhisperModels: async () => ({
success: true,
models: [...inventory.whisper].map((model) => ({ model, downloaded: true })),
}),
listParakeetModels: async () => ({
success: true,
models: [...inventory.parakeet].map((model) => ({ model, downloaded: true })),
}),
modelGetAll: async () =>
[...inventory.llm].map((id) => ({ id, isDownloaded: true, isDownloading: false })),
modelGetActiveDownloads: async () => [],
downloadWhisperModel: startDownload("whisper"),
downloadParakeetModel: startDownload("parakeet"),
modelDownload: startDownload("llm"),
modelCancelDownload: async (modelId) => {
const response = {
success: false,
code: "DOWNLOAD_CANCELLED",
error: "Download cancelled by user",
};
for (const listener of listeners.llm) {
listener({}, { type: "error", modelId, code: response.code, error: response.error });
}
requests.get(modelId).resolve(response);
return { success: true };
},
onWhisperDownloadProgress: subscribe("whisper"),
onParakeetDownloadProgress: subscribe("parakeet"),
onModelDownloadProgress: subscribe("llm"),
},
},
});
const container = installHookDom(t);
const vite = await createRendererServer(t, {
cachePrefix: "openwhispr-local-setup-test-",
noExternal: ["react-i18next"],
mockModules: {
"react-i18next": `
const t = (key) => key;
export function useTranslation() { return { t }; }
export const initReactI18next = { type: "3rdParty", init() {} };
`,
"/OnboardingShell": `export function BrandMark() { return null; }`,
"/ui/ProviderIcon": `export function ProviderIcon() { return null; }`,
},
});
const { useSettingsStore } = await vite.ssrLoadModule("/stores/settingsStore.ts");
useSettingsStore.setState({
localTranscriptionProvider: provider === "nvidia" ? "nvidia" : "whisper",
whisperModel: !assistant && provider === "whisper" ? selectedModel : "",
parakeetModel: !assistant && provider === "nvidia" ? selectedModel : "",
chatAgentProvider: assistant ? provider : "qwen",
chatAgentModel: assistant ? selectedModel : "",
chatAgentMode: "local",
});
// The store setter also persists the choice; only a fresh install has no key.
if (!assistant && !freshInstall) {
localStorage.setItem(
"localTranscriptionProvider",
provider === "nvidia" ? "nvidia" : "whisper"
);
}
const { LocalModelSetupStep } = await vite.ssrLoadModule(
"/components/onboarding/ProviderSetupStep.tsx"
);
const { ToastContext } = await vite.ssrLoadModule("/components/ui/useToast.ts");
const pending = await vite.ssrLoadModule("/components/onboarding/pendingLocalModels.ts");
const { default: BackgroundModelDownloadTray } = await vite.ssrLoadModule(
"/components/onboarding/BackgroundModelDownloadTray.tsx"
);
let tree;
let trayTree;
let ready = false;
let proceeded = false;
let skipped = false;
const resumeDrafts = [];
const props = {
stepId: assistant ? "local-assistant" : "local-dictation",
onReadinessChange: (value) => {
ready = value;
},
onProceed() {
proceeded = true;
},
onSkip() {
skipped = true;
},
resumeState,
onResumeStateChange: (draft) => resumeDrafts.push(draft),
};
function Harness() {
// Execute the real component and hooks with React lifecycle, while leaving
// native controls unmounted: their returned handlers are the test boundary.
tree = LocalModelSetupStep(props);
trayTree = BackgroundModelDownloadTray({ placement: "onboarding" });
return null;
}
const root = createRoot(container);
const toast = { toast: () => "test-toast" };
await React.act(async () => {
root.render(
React.createElement(ToastContext.Provider, { value: toast }, React.createElement(Harness))
);
});
unmount = async () => {
await React.act(async () => root.unmount());
};
const row = (modelId) => {
const element = findElement(tree, (node) => node.type === "div" && node.key === modelId);
assert.ok(element, `model row ${modelId} is visible`);
return element;
};
const click = async (modelId, action) => {
const button = findElement(
row(modelId),
(node) => typeof node.props?.onClick === "function" && textContent(node) === action
);
assert.ok(button, `${action} is available for ${modelId}: ${textContent(row(modelId))}`);
await React.act(async () => button.props.onClick());
};
const emit = async (family, event) => {
await React.act(async () => {
for (const listener of listeners[family]) listener({}, event);
});
};
const progress = async (modelId, percentage, phase = "progress") => {
const family = requests.get(modelId).family;
const event =
family === "llm"
? { modelId, type: phase, progress: percentage, downloadedSize: percentage, totalSize: 100 }
: {
model: modelId,
type: phase,
percentage,
downloaded_bytes: percentage,
total_bytes: 100,
};
await emit(family, event);
};
const complete = async (modelId) => {
const request = requests.get(modelId);
assert.ok(request, `download ${modelId} started`);
inventory[request.family].add(modelId);
await React.act(async () => {
for (const listener of listeners[request.family]) {
listener(
{},
request.family === "llm"
? { type: "complete", modelId, progress: 100 }
: { type: "complete", model: modelId, percentage: 100 }
);
}
request.resolve({ success: true });
});
};
const trayRow = (key) => {
const element = findElement(trayTree, (node) => node.type === "div" && node.key === key);
assert.ok(element, `tray row ${key} is visible`);
return element;
};
const actionButton = (label) =>
findElement(
tree,
(node) => typeof node.props?.onClick === "function" && textContent(node) === label
);
return {
store: useSettingsStore,
pending,
row,
click,
progress,
complete,
emit,
trayRow,
cancel: async (modelId) => {
const button = findElement(trayRow(`llm:${modelId}`), (node) => node.type === "button");
await React.act(async () => button.props.onClick());
},
trayHeader: () => {
const header = findElement(
trayTree,
(node) => node.type === "div" && String(node.props?.className).includes("gap-[5px]")
);
assert.ok(header, "tray header is visible");
return textContent(header);
},
chooseProvider: async (providerId) => {
const select = findElement(tree, (node) => typeof node.props?.onValueChange === "function");
await React.act(async () => select.props.onValueChange(providerId));
},
proceed: async () => {
const button = actionButton("onboarding.rehaul.provider.proceed");
assert.equal(button.props.disabled, false, "Proceed is enabled");
await React.act(async () => button.props.onClick());
},
skip: async () => {
const button = actionButton("common.skip");
assert.ok(button && !button.props.disabled, "Skip is enabled");
await React.act(async () => button.props.onClick());
},
proceeded: () => proceeded,
skipped: () => skipped,
ready: () => ready,
resumeDrafts: () => resumeDrafts,
canProceed: () => !actionButton("onboarding.rehaul.provider.proceed").props.disabled,
canSkip: () => {
const button = actionButton("common.skip");
return Boolean(button && !button.props.disabled);
},
};
}
for (const fixture of [
{ family: "whisper", provider: "whisper", modelId: "base", setting: "whisperModel" },
{
family: "parakeet",
provider: "nvidia",
modelId: "parakeet-tdt-0.6b-v3",
setting: "parakeetModel",
},
{ family: "llm", provider: "qwen", modelId: FIRST_LLM, setting: "chatAgentModel" },
]) {
test(`Use selects an installed ${fixture.family} model without a pending download`, async (t) => {
const setup = await createSetupHarness(t, {
assistant: fixture.family === "llm",
provider: fixture.provider,
installed: { [fixture.family]: [fixture.modelId] },
});
assert.equal(setup.canProceed(), false);
await setup.click(fixture.modelId, "onboarding.rehaul.local.use");
assert.equal(setup.store.getState()[fixture.setting], fixture.modelId);
assert.equal(setup.ready(), true);
assert.equal(setup.canProceed(), true);
});
}
test("a fresh install opens the local dictation step on Oruk with Orukeet offered", async (t) => {
const setup = await createSetupHarness(t, { freshInstall: true });
assert.ok(setup.row("orukeet-v0.1.0"));
assert.throws(() => setup.row("base"));
});
test("an explicit installed-model choice supersedes an earlier pending download", async (t) => {
const setup = await createSetupHarness(t, { assistant: true, installed: { llm: [SECOND_LLM] } });
await setup.click(FIRST_LLM, "onboarding.rehaul.local.download");
await setup.click(SECOND_LLM, "onboarding.rehaul.local.use");
assert.equal(setup.pending.hasPendingLocalModels(), false);
assert.equal(setup.canProceed(), true);
assert.equal(setup.canSkip(), true);
await setup.complete(FIRST_LLM);
assert.equal(setup.store.getState().chatAgentModel, SECOND_LLM);
assert.equal(setup.ready(), true);
});
test("completion enables Proceed after the background tray consumes the pending selection", async (t) => {
const setup = await createSetupHarness(t, { assistant: true });
await setup.click(FIRST_LLM, "onboarding.rehaul.local.download");
localStorage.setItem("localSetupPending", "true");
await setup.complete(FIRST_LLM);
assert.equal(setup.pending.hasPendingLocalModels(), false);
assert.equal(setup.store.getState().chatAgentModel, FIRST_LLM);
assert.equal(setup.ready(), true);
assert.equal(setup.canProceed(), true);
});
test("simultaneous assistant downloads display their own progress", async (t) => {
const setup = await createSetupHarness(t, { assistant: true });
await setup.click(FIRST_LLM, "onboarding.rehaul.local.download");
await setup.click(SECOND_LLM, "onboarding.rehaul.local.download");
await setup.progress(FIRST_LLM, 10);
await setup.progress(SECOND_LLM, 80);
assert.match(textContent(setup.row(FIRST_LLM)), /10%/);
assert.match(textContent(setup.row(SECOND_LLM)), /80%/);
});
test("the most recently started assistant download owns pending selection", async (t) => {
const setup = await createSetupHarness(t, { assistant: true });
await setup.click(FIRST_LLM, "onboarding.rehaul.local.download");
await setup.click(SECOND_LLM, "onboarding.rehaul.local.download");
assert.equal(setup.pending.readPendingLocalModels().assistant.modelId, SECOND_LLM);
await setup.complete(FIRST_LLM);
assert.equal(setup.store.getState().chatAgentModel, "");
await setup.complete(SECOND_LLM);
assert.equal(setup.store.getState().chatAgentModel, SECOND_LLM);
assert.equal(setup.ready(), true);
});
test("a refused concurrent Whisper download preserves the original pending selection", async (t) => {
const setup = await createSetupHarness(t);
await setup.click("base", "onboarding.rehaul.local.download");
await setup.click("small", "onboarding.rehaul.local.download");
assert.equal(setup.pending.readPendingLocalModels().dictation.modelId, "base");
await setup.complete("base");
assert.equal(setup.store.getState().whisperModel, "base");
assert.equal(setup.ready(), true);
});
test("cancelling the newest assistant download permits Skip without activating an older model", async (t) => {
const setup = await createSetupHarness(t, { assistant: true });
await setup.click(FIRST_LLM, "onboarding.rehaul.local.download");
await setup.click(SECOND_LLM, "onboarding.rehaul.local.download");
await setup.progress(FIRST_LLM, 10);
await setup.progress(SECOND_LLM, 20);
await setup.cancel(SECOND_LLM);
assert.equal(setup.pending.hasPendingLocalModels(), false);
assert.deepEqual(
{ proceed: setup.canProceed(), skip: setup.canSkip() },
{ proceed: false, skip: true }
);
await setup.skip();
assert.equal(setup.skipped(), true);
await setup.complete(FIRST_LLM);
assert.equal(setup.store.getState().chatAgentModel, "");
assert.equal(setup.canProceed(), false);
await setup.click(FIRST_LLM, "onboarding.rehaul.local.use");
assert.equal(setup.store.getState().chatAgentModel, FIRST_LLM);
assert.equal(setup.canProceed(), true);
});
test("cancelling an older assistant download preserves the pending background selection", async (t) => {
const setup = await createSetupHarness(t, { assistant: true });
await setup.click(FIRST_LLM, "onboarding.rehaul.local.download");
await setup.click(SECOND_LLM, "onboarding.rehaul.local.download");
await setup.progress(FIRST_LLM, 10);
await setup.progress(SECOND_LLM, 20);
await setup.cancel(FIRST_LLM);
assert.equal(setup.pending.readPendingLocalModels().assistant.modelId, SECOND_LLM);
assert.equal(setup.canProceed(), true);
assert.equal(setup.canSkip(), true);
await setup.proceed();
assert.equal(setup.proceeded(), true);
assert.equal(localStorage.getItem("localSetupPending"), "true");
await setup.complete(SECOND_LLM);
assert.equal(setup.store.getState().chatAgentModel, SECOND_LLM);
assert.equal(setup.ready(), true);
});
test("browsing another dictation provider preserves the active pending background selection", async (t) => {
const setup = await createSetupHarness(t);
await setup.click("base", "onboarding.rehaul.local.download");
await setup.chooseProvider("nvidia");
assert.equal(setup.canProceed(), true);
assert.equal(setup.canSkip(), true);
await setup.proceed();
assert.equal(localStorage.getItem("localSetupPending"), "true");
await setup.complete("base");
assert.equal(setup.store.getState().localTranscriptionProvider, "whisper");
assert.equal(setup.store.getState().whisperModel, "base");
});
test("a resumed local-model draft overrides the previously saved model", async (t) => {
const setup = await createSetupHarness(t, {
assistant: true,
installed: { llm: [FIRST_LLM, SECOND_LLM] },
selectedModel: FIRST_LLM,
resumeState: { provider: "qwen", modelId: SECOND_LLM },
});
assert.match(textContent(setup.row(SECOND_LLM)), /onboarding\.rehaul\.local\.selected/);
assert.match(textContent(setup.row(FIRST_LLM)), /onboarding\.rehaul\.local\.use/);
assert.equal(setup.ready(), true);
assert.equal(setup.canProceed(), true);
});
test("Skip marks a pending model for background activation", async (t) => {
const setup = await createSetupHarness(t, { assistant: true });
await setup.click(FIRST_LLM, "onboarding.rehaul.local.download");
assert.equal(setup.canSkip(), true);
await setup.skip();
assert.equal(localStorage.getItem("localSetupPending"), "true");
});
test("the assistant step can be skipped with no model selected or downloading", async (t) => {
const setup = await createSetupHarness(t, { assistant: true });
assert.equal(setup.canProceed(), false);
await setup.skip();
assert.equal(setup.skipped(), true);
});
test("choosing a local model records it in the resume draft", async (t) => {
const setup = await createSetupHarness(t, {
assistant: true,
installed: { llm: [FIRST_LLM, SECOND_LLM] },
selectedModel: FIRST_LLM,
});
await setup.click(SECOND_LLM, "onboarding.rehaul.local.use");
// Without this the pick is only in component state, so relaunching mid-setup
// silently reverts to whatever was saved before onboarding started.
assert.deepEqual(setup.resumeDrafts().at(-1), { provider: "qwen", modelId: SECOND_LLM });
});
test("Oruk installs and activates Orukeet through the existing parakeet download flow", async (t) => {
const modelId = "orukeet-v0.1.0";
const setup = await createSetupHarness(t);
await setup.chooseProvider("oruk");
assert.match(textContent(setup.row(modelId)), /common\.recommended/);
assert.equal(setup.store.getState().localTranscriptionProvider, "whisper");
await setup.click(modelId, "onboarding.rehaul.local.download");
assert.deepEqual(setup.pending.readPendingLocalModels().dictation, {
provider: "nvidia",
modelId,
});
await setup.complete(modelId);
assert.equal(setup.store.getState().localTranscriptionProvider, "nvidia");
assert.equal(setup.store.getState().parakeetModel, modelId);
assert.equal(setup.ready(), true);
assert.equal(setup.canProceed(), true);
});
test("browsing Oruk preserves an installed stock Parakeet selection", async (t) => {
const modelId = "parakeet-tdt-0.6b-v3";
const setup = await createSetupHarness(t, {
provider: "nvidia",
installed: { parakeet: [modelId] },
});
await setup.click(modelId, "onboarding.rehaul.local.use");
await setup.chooseProvider("oruk");
assert.equal(setup.store.getState().parakeetModel, modelId);
assert.equal(setup.store.getState().localTranscriptionProvider, "nvidia");
assert.equal(setup.ready(), false);
});
test("unsupported Macs cannot choose Oruk or NVIDIA during local onboarding", async (t) => {
const setup = await createSetupHarness(t, {
provider: "nvidia",
capability: { supported: false, minimumMacOSVersion: "15.5" },
});
assert.ok(setup.row("base"));
for (const provider of ["oruk", "nvidia"]) {
await setup.chooseProvider(provider);
assert.ok(setup.row("base"));
assert.equal(setup.ready(), false);
}
});
test("the tray header follows the transfer into its installing phase", async (t) => {
const modelId = "parakeet-tdt-0.6b-v3";
const setup = await createSetupHarness(t, { provider: "nvidia" });
await setup.click(modelId, "onboarding.rehaul.local.download");
await setup.progress(modelId, 100);
assert.equal(setup.trayHeader(), "onboarding.rehaul.local.downloadInProgress");
// Extraction reports no further bytes, so the header is the only thing left
// that can tell a full bar apart from a stalled one.
await setup.progress(modelId, 100, "installing");
assert.equal(setup.trayHeader(), "onboarding.rehaul.local.installing");
});
test("an extracting row says so while another model is still downloading", async (t) => {
const setup = await createSetupHarness(t, { assistant: true });
await setup.click(FIRST_LLM, "onboarding.rehaul.local.download");
await setup.progress(FIRST_LLM, 40);
// The tray outlives the step that started a transfer, so a dictation model
// picked earlier keeps extracting behind the assistant step.
await setup.emit("parakeet", { model: PARAKEET, type: "installing", percentage: 100 });
assert.match(
textContent(setup.trayRow(`parakeet:${PARAKEET}`)),
/onboarding\.rehaul\.local\.installing/
);
assert.match(textContent(setup.trayRow(`llm:${FIRST_LLM}`)), /40%/);
// Not every row has reached extraction, so the strip stays on downloading.
assert.equal(setup.trayHeader(), "onboarding.rehaul.local.downloadInProgress");
});