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 test = require("node:test");
const assert = require("node:assert/strict");
const fs = require("node:fs");
const path = require("node:path");
const { createDb } = require("../helpers/harness/db");
const { createRendererServer, installBrowserGlobals } = require("../lib/rendererTestHarness");
for (const source of ["file", "url"]) {
for (const timed of [false, true]) {
test(`${source} upload stores ${timed ? "timed" : "text-only"} transcription separately at creation`, async (t) => {
const db = createDb(t);
assert.ok(db);
const handwritten = db.saveNote("My notes", "Keep my handwritten notes").note;
const meeting = db.saveNote("Existing meeting", "Meeting notes", "meeting").note;
db.updateNote(meeting.id, { transcript: "Existing transcript", enhanced_content: "Summary" });
const originals = [db.getNote(handwritten.id), db.getNote(meeting.id)];
const text = "Public synthetic transcript.\nSecond paragraph.";
const segments = timed ? [{ text, start: 2, end: 5, speaker: "Speaker 1" }] : undefined;
const created = [];
const { window } = installBrowserGlobals(t);
Object.assign(window.electronAPI, {
transcribeAudioFile: async () => ({ success: true, text, segments, durationSeconds: 12 }),
downloadUrlAudio: async () => ({
success: true,
tempPath: "/synthetic/file.wav",
title: "Public title",
sizeBytes: 100,
}),
onUrlDownloadProgress: () => () => {},
saveNote: async (...args) => {
const result = db.saveNote(...args);
created.push(result.note);
return result;
},
// Metadata failure must never lose the already-created transcript.
updateNote: async () => {
throw new Error("metadata unavailable");
},
deleteTempFile: () => {},
});
const vite = await createRendererServer(t, {
mockModules: {
"/lib/auth": "export const withSessionRefresh = (fn) => fn();",
"./settingsStore": "export const getSettings = () => ({});",
"./policyStore": "export const usePolicyStore = { getState: () => ({}) };",
"./policyRules": "export const isTranscriptionContextAllowed = () => true;",
},
});
const queue = await vite.ssrLoadModule("/stores/batchQueueStore.ts");
if (source === "file")
queue.addFiles([{ name: "fixture.wav", path: "/synthetic/file.wav", sizeBytes: 100 }]);
else queue.addUrls(["https://www.youtube.com/watch?v=public123"]);
queue.processBatchQueue(
{
transcription: {
useLocalWhisper: true,
localTranscriptionProvider: "whisper",
whisperModel: "base",
parakeetModel: "unused",
isOpenWhisprCloud: false,
getApiKey: () => "",
cloudTranscriptionProvider: "openai",
cloudTranscriptionBaseUrl: "",
cloudTranscriptionModel: "whisper-1",
language: "en",
},
folderId: null,
generateTitle: async () => "Generated title",
},
{ enabled: timed, localModelsReady: false, numSpeakers: null }
);
const deadline = Date.now() + 5000;
while (queue.useBatchQueueStore.getState().isProcessing && Date.now() < deadline) {
await new Promise((resolve) => setTimeout(resolve, 10));
}
const item = queue.useBatchQueueStore.getState().queue[0];
assert.equal(item.status, "done");
const note = db.getNote(item.noteId);
assert.equal(note.content, "");
assert.equal(
created[0].transcript,
note.transcript,
"initial note-added/mirror snapshot includes transcript"
);
assert.deepEqual(
JSON.parse(note.transcript).map((segment) => segment.text),
[text]
);
assert.equal(JSON.parse(note.transcript)[0].speaker, timed ? "speaker_0" : undefined);
assert.equal(typeof JSON.parse(note.transcript)[0].timestamp, timed ? "number" : "undefined");
assert.equal(note.note_type, "upload");
assert.equal(note.title, source === "file" ? "Generated title" : "Public title");
assert.equal(note.source_file, source === "file" ? "fixture.wav" : "Public title");
assert.deepEqual([db.getNote(handwritten.id), db.getNote(meeting.id)], originals);
const filename = db.db.name;
db.db.close();
db.db = new (require("better-sqlite3"))(filename);
assert.equal(db.getNote(note.id).transcript, note.transcript);
const mirror = require("../../src/helpers/markdownMirror");
const mirrorPath = path.join(path.dirname(filename), "mirror");
mirror.init(mirrorPath);
mirror.writeNote(note, "Personal");
mirror.writeTranscript(note, "Personal", {});
const transcriptPath = fs
.readdirSync(path.join(mirrorPath, "Personal"))
.find((name) => name.endsWith("-transcript.md"));
assert.ok(transcriptPath);
assert.ok(
fs.readFileSync(path.join(mirrorPath, "Personal", transcriptPath), "utf8").includes(text)
);
});
}
}
test("upload transcript crosses the actual preload and save IPC handler before broadcasting", async (t) => {
const db = createDb(t);
assert.ok(db);
const vm = require("node:vm");
const ts = require("typescript");
const source = ts.createSourceFile(
"ipcHandlers.js",
fs.readFileSync("src/helpers/ipcHandlers.js", "utf8"),
ts.ScriptTarget.Latest,
true
);
let callback;
function visit(node) {
if (ts.isCallExpression(node) && node.arguments[0]?.text === "db-save-note") {
callback = node.arguments[1].getText(source);
}
ts.forEachChild(node, visit);
}
visit(source);
assert.ok(callback);
const broadcasts = [];
const mirrored = [];
const owner = {
databaseManager: db,
notifyVectorChanges() {},
_asyncMirrorWrite: (note) => mirrored.push(note),
};
const handler = vm.runInNewContext(`(function () { return (${callback}); }).call(owner)`, {
owner,
setImmediate: (fn) => fn(),
broadcastToWindows: (...args) => broadcasts.push(args),
});
const { window } = installBrowserGlobals(t);
vm.runInNewContext(fs.readFileSync("preload.js", "utf8"), {
process,
require: (name) => {
assert.equal(name, "electron");
return {
contextBridge: {
exposeInMainWorld: (_name, api) => {
window.electronAPI = api;
},
},
webUtils: {},
ipcRenderer: {
invoke: async (channel, ...args) => {
assert.equal(channel, "db-save-note");
return handler.call(owner, {}, ...args);
},
on() {},
removeListener() {},
send() {},
sendSync() {},
},
};
},
});
const { saveUploadNote } = await import("../../src/services/uploadNotes.ts");
const saved = await saveUploadNote({
title: "Atomic upload",
text: "Public fixture words",
sourceName: "fixture.wav",
folderId: null,
diarization: { enabled: false, localModelsReady: false, numSpeakers: null },
});
const stored = db.getNote(saved.note.id);
assert.equal(stored.content, "");
assert.deepEqual(JSON.parse(stored.transcript), [{ text: "Public fixture words" }]);
assert.equal(broadcasts[0][0], "note-added");
assert.equal(broadcasts[0][1].transcript, stored.transcript);
assert.equal(mirrored[0].transcript, stored.transcript);
});
test("a segment without a start keeps the complete uploaded text without invented times", async (t) => {
const db = createDb(t);
assert.ok(db);
const { window } = installBrowserGlobals(t);
window.electronAPI.saveNote = async (...args) => db.saveNote(...args);
const { saveUploadNote } = await import("../../src/services/uploadNotes.ts");
const text = "First sentence. Second sentence.";
const saved = await saveUploadNote({
title: "Full result",
text,
sourceName: "fixture.wav",
folderId: null,
segments: [
{ text: "First sentence.", start: 0 },
{ text: "Second sentence.", start: NaN },
],
diarization: { enabled: false, localModelsReady: false, numSpeakers: null },
});
assert.equal(saved.note.content, "");
assert.deepEqual(JSON.parse(db.getNote(saved.note.id).transcript), [{ text }]);
});
// The provider's text is formatted for reading (speaker headers) or joined
// without spaces (CJK), so it never equals the segments' text; the segments
// still hold the words, and their timing and speakers must survive.
for (const { name, text, segments, speakers } of [
{
name: "a provider-diarized upload keeps its speakers and times",
text: "[A] 00:00 - 00:02\nhello there\n\n[B] 00:02 - 00:04\nhi back",
segments: [
{ speaker: "A", text: "hello there", start: 0, end: 2 },
{ speaker: "B", text: "hi back", start: 2, end: 4 },
],
speakers: ["speaker_0", "speaker_1"],
},
{
name: "a CJK upload keeps its segment times",
text: "你好。今天开会。",
segments: [
{ text: "你好。", start: 0, end: 1 },
{ text: "今天开会。", start: 1, end: 2 },
],
speakers: [undefined, undefined],
},
]) {
test(name, async (t) => {
const db = createDb(t);
assert.ok(db);
const { window } = installBrowserGlobals(t);
window.electronAPI.saveNote = async (...args) => db.saveNote(...args);
const { saveUploadNote } = await import("../../src/services/uploadNotes.ts");
const saved = await saveUploadNote({
title: "Timed",
text,
sourceName: "fixture.wav",
folderId: null,
segments,
diarization: { enabled: false, localModelsReady: false, numSpeakers: null },
});
const stored = JSON.parse(db.getNote(saved.note.id).transcript);
assert.deepEqual(
stored.map((segment) => segment.text),
segments.map((segment) => segment.text)
);
assert.deepEqual(
stored.map((segment) => segment.speaker),
speakers
);
assert.equal(
stored[1].timestamp - stored[0].timestamp,
(segments[1].start - segments[0].start) * 1000
);
});
}
test("upload creation keeps its selected workspace and sends transcript in the real cloud payload", async (t) => {
const db = createDb(t);
assert.ok(db);
db.setActiveAccountId("synthetic-account");
const space = db.db
.prepare(
"INSERT INTO spaces (client_space_id, kind, name, sort_order) VALUES (?, 'team', ?, 1)"
)
.run("synthetic-space", "Target workspace");
const spaceId = Number(space.lastInsertRowid);
db.db
.prepare("INSERT INTO space_accounts (space_id, account_id) VALUES (?, ?)")
.run(spaceId, "synthetic-account");
const folder = db.createFolder("Target folder", spaceId).folder;
assert.ok(folder);
const calls = [];
const { window } = installBrowserGlobals(t);
Object.assign(window.electronAPI, {
saveNote: async (...args) => db.saveNote(...args),
cloudApiRequest: async (request) => {
assert.equal(request.path, "/api/notes/create");
calls.push(JSON.parse(JSON.stringify(request)));
return {
success: true,
data: {
...request.body,
id: "synthetic-cloud-note",
updated_at: "2026-10-22T00:00:00Z",
user_id: "synthetic-account",
row_created: true,
write_applied: true,
},
};
},
acknowledgeNoteCreate: async (...args) => db.acknowledgeNoteCreate(...args),
getNote: async (id) => db.getNote(id),
});
const vite = await createRendererServer(t);
const { saveUploadNote } = await vite.ssrLoadModule("/services/uploadNotes.ts");
const text = "Full uploaded words for cloud backup.";
const saved = await saveUploadNote({
title: "Scoped upload",
text,
sourceName: "fixture.wav",
folderId: folder.id,
diarization: { enabled: false, localModelsReady: false, numSpeakers: null },
});
const note = db.getNote(saved.note.id);
assert.equal(note.folder_id, folder.id);
assert.equal(note.space_id, spaceId);
const { SyncService } = await vite.ssrLoadModule("/services/SyncService.ts");
const service = new SyncService();
await service.createCloudNote(note, "synthetic-cloud-folder", {
space_id: "synthetic-cloud-space",
});
assert.equal(calls.length, 1);
const { body } = calls[0];
assert.equal(body.content, "");
assert.equal(body.transcript, note.transcript);
assert.deepEqual(JSON.parse(body.transcript), [{ text }]);
assert.equal(body.folder_id, "synthetic-cloud-folder");
assert.equal(body.space_id, "synthetic-cloud-space");
const { buildNoteUpdatePayload } = await vite.ssrLoadModule("/helpers/cloudSyncGuards.js");
const update = JSON.parse(
JSON.stringify(buildNoteUpdatePayload({ ...note, cloud_revision: 3 }, "synthetic-cloud-folder"))
);
assert.equal(update.transcript, note.transcript);
});