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 path = require("path");
const fs = require("fs");
const fsPromises = require("fs/promises");
const { app } = require("electron");
const debugLogger = require("./debugLogger");
const { normalizeUiLanguage } = require("./i18nMain");
const secretCrypto = require("./secretCrypto");
const { BYOK_API_KEYS } = require("../config/secretKeys");
const SECRET_KEYS = [
...BYOK_API_KEYS.map((k) => k.env),
"CORTI_CLIENT_ID",
"CORTI_CLIENT_SECRET",
"CUSTOM_TRANSCRIPTION_API_KEY",
"CUSTOM_CLEANUP_API_KEY",
"BEDROCK_ACCESS_KEY_ID",
"BEDROCK_SECRET_ACCESS_KEY",
"BEDROCK_SESSION_TOKEN",
"AZURE_OPENAI_API_KEY",
"VERTEX_API_KEY",
];
const SECRET_KEY_SET = new Set(SECRET_KEYS);
const PERSISTED_KEYS = [
...SECRET_KEYS,
"LOCAL_TRANSCRIPTION_PROVIDER",
"PARAKEET_MODEL",
"DICTATION_LANGUAGE",
"LOCAL_WHISPER_MODEL",
"CLEANUP_PROVIDER",
"LOCAL_CLEANUP_MODEL",
"DICTATION_AGENT_PROVIDER",
"LOCAL_DICTATION_AGENT_MODEL",
"LLAMA_GPU_BACKEND",
"LLAMA_VULKAN_ENABLED",
"DICTATION_KEY",
"VOICE_AGENT_KEY",
"TRANSLATION_KEY",
"MEETING_KEY",
"ACTIVATION_MODE",
"FLOATING_ICON_AUTO_HIDE",
"PANEL_START_POSITION",
"START_MINIMIZED",
"UI_LANGUAGE",
"WHISPER_CUDA_ENABLED",
"WHISPER_VULKAN_ENABLED",
"WHISPER_VULKAN_DEVICE",
"WHISPER_GPU_FAILED",
"WHISPER_GPU_FAILED_REASON_CUDA",
"WHISPER_GPU_FAILED_REASON_VULKAN",
"WHISPER_THREADS",
"TRANSCRIPTION_GPU_UUID",
"INTELLIGENCE_GPU_UUID",
"BEDROCK_REGION",
"BEDROCK_PROFILE",
"AZURE_OPENAI_ENDPOINT",
"AZURE_OPENAI_DEPLOYMENT",
"AZURE_OPENAI_API_VERSION",
"VERTEX_PROJECT",
"VERTEX_LOCATION",
// Written by the Settings debug toggle (set-debug-logging)
"OPENWHISPR_LOG_LEVEL",
];
// Module-level so writes are serialized across all instances — hotkeyManager
// creates its own EnvironmentManager alongside the main.js singleton.
let envWriteQueue = Promise.resolve();
class EnvironmentManager {
constructor() {
this.loadEnvironmentVariables();
}
loadEnvironmentVariables() {
// App config (.env in userData) takes precedence over system env vars,
// so keys saved by the user in Settings always win.
const userDataEnv = path.join(app.getPath("userData"), ".env");
try {
if (fs.existsSync(userDataEnv)) {
require("dotenv").config({ path: userDataEnv, override: true });
}
} catch {}
const fallbackPaths = [
path.join(__dirname, "..", "..", ".env"), // Development
path.join(process.resourcesPath, ".env"),
path.join(process.resourcesPath, "app.asar.unpacked", ".env"),
path.join(process.resourcesPath, "app", ".env"), // Legacy
];
for (const envPath of fallbackPaths) {
try {
if (fs.existsSync(envPath)) {
require("dotenv").config({ path: envPath });
}
} catch {}
}
}
// Encryption initializes lazily. Probing it eagerly would touch the macOS
// Keychain before any window is visible. Migration and _loadAllSecrets are
// both no-ops on fresh installs, so neither path triggers Keychain until
// the user actually saves their first secret.
async init() {
if (!fs.existsSync(this._getMigrationSentinelPath())) {
await this._migrateToSecureStorage();
}
await this._loadAllSecrets();
}
_getMigrationSentinelPath() {
return path.join(this._getSecureKeysDir(), ".migrated");
}
_encryptionAvailable() {
try {
return secretCrypto.isAvailable();
} catch {
return false;
}
}
_getSecureKeysDir() {
return path.join(app.getPath("userData"), "secure-keys");
}
_getSecretFilePath(envVarName) {
return path.join(this._getSecureKeysDir(), `${envVarName}.enc`);
}
async _loadAllSecrets() {
await Promise.all(SECRET_KEYS.map((name) => this._loadSecretKey(name)));
}
async _loadSecretKey(envVarName) {
const filePath = this._getSecretFilePath(envVarName);
try {
const buffer = await fsPromises.readFile(filePath);
const { value, needsReencrypt } = secretCrypto.decrypt(buffer);
process.env[envVarName] = value;
if (needsReencrypt) await this._saveSecretKey(envVarName, value);
} catch (error) {
if (error.code === "ENOENT") return;
debugLogger.error(
"Failed to decrypt secret — user must re-enter",
{ key: envVarName, code: error.code, error: error.message },
"environment"
);
}
}
async _saveSecretKey(envVarName, value) {
if (!value) {
await this._deleteSecretKey(envVarName);
return;
}
process.env[envVarName] = value;
const dir = this._getSecureKeysDir();
await fsPromises.mkdir(dir, { recursive: true });
const filePath = this._getSecretFilePath(envVarName);
const tmpPath = `${filePath}.tmp`;
const encrypted = secretCrypto.encrypt(value);
await fsPromises.writeFile(tmpPath, encrypted);
await fsPromises.rename(tmpPath, filePath);
}
async _deleteSecretKey(envVarName) {
delete process.env[envVarName];
try {
await fsPromises.unlink(this._getSecretFilePath(envVarName));
} catch (error) {
if (error.code !== "ENOENT") throw error;
}
}
async _migrateToSecureStorage() {
const dir = this._getSecureKeysDir();
await fsPromises.mkdir(dir, { recursive: true });
// Adopt renamed key so the value survives migration. Old releases stored
// it under CUSTOM_REASONING_API_KEY; new code only encrypts CUSTOM_CLEANUP_API_KEY.
if (process.env.CUSTOM_REASONING_API_KEY && !process.env.CUSTOM_CLEANUP_API_KEY) {
process.env.CUSTOM_CLEANUP_API_KEY = process.env.CUSTOM_REASONING_API_KEY;
}
delete process.env.CUSTOM_REASONING_API_KEY;
const migrated = [];
try {
for (const name of SECRET_KEYS) {
const value = process.env[name];
if (!value) continue;
await this._saveSecretKey(name, value);
// Round-trip verify before stripping plaintext .env.
const buffer = await fsPromises.readFile(this._getSecretFilePath(name));
if (secretCrypto.decrypt(buffer).value !== value) {
throw new Error(`round-trip verification failed for ${name}`);
}
migrated.push(name);
}
} catch (error) {
debugLogger.error(
"Secret migration aborted — plaintext .env preserved",
{ error: error.message, migrated },
"environment"
);
return;
}
// Write sentinel before stripping plaintext from .env so a crash mid-rewrite is recoverable.
await fsPromises.writeFile(this._getMigrationSentinelPath(), "");
const envPath = path.join(app.getPath("userData"), ".env");
if (fs.existsSync(envPath)) await this._writeEnvFileAtomic(envPath);
debugLogger.info(
"Migrated secrets to encrypted storage",
{ count: migrated.length },
"environment"
);
}
_writeEnvFileAtomic(envPath) {
// Concurrent write+rename pairs share the same .env.tmp path, and the
// loser's rename throws ENOENT (#903).
envWriteQueue = envWriteQueue.catch(() => {}).then(() => this._writeEnvFile(envPath));
return envWriteQueue;
}
async _writeEnvFile(envPath) {
// Only strip plaintext secrets once migration has fully completed —
// otherwise a partial-migration recovery can lose unencrypted secrets.
const stripSecrets =
this._encryptionAvailable() && fs.existsSync(this._getMigrationSentinelPath());
let envContent = "# OpenWhispr Environment Variables\n";
for (const key of PERSISTED_KEYS) {
if (stripSecrets && SECRET_KEY_SET.has(key)) continue;
if (process.env[key]) {
envContent += `${key}=${process.env[key]}\n`;
}
}
const tmpPath = `${envPath}.tmp`;
await fsPromises.writeFile(tmpPath, envContent, "utf8");
await fsPromises.rename(tmpPath, envPath);
}
_getKey(envVarName) {
return process.env[envVarName] || "";
}
_saveKey(envVarName, key) {
if (SECRET_KEY_SET.has(envVarName) && this._encryptionAvailable()) {
this._saveSecretKey(envVarName, key).catch((error) => {
debugLogger.error(
"Failed to persist encrypted secret",
{ key: envVarName, error: error.message },
"environment"
);
});
} else if (key) {
process.env[envVarName] = key;
} else {
delete process.env[envVarName];
}
return { success: true };
}
getCortiClientId() {
return this._getKey("CORTI_CLIENT_ID");
}
saveCortiClientId(key) {
return this._saveKey("CORTI_CLIENT_ID", key);
}
getCortiClientSecret() {
return this._getKey("CORTI_CLIENT_SECRET");
}
saveCortiClientSecret(key) {
return this._saveKey("CORTI_CLIENT_SECRET", key);
}
getCustomTranscriptionKey() {
return this._getKey("CUSTOM_TRANSCRIPTION_API_KEY");
}
saveCustomTranscriptionKey(key) {
return this._saveKey("CUSTOM_TRANSCRIPTION_API_KEY", key);
}
getCleanupCustomKey() {
// TODO: drop CUSTOM_REASONING_API_KEY fallback after 2 releases.
return this._getKey("CUSTOM_CLEANUP_API_KEY") || this._getKey("CUSTOM_REASONING_API_KEY");
}
saveCleanupCustomKey(key) {
delete process.env.CUSTOM_REASONING_API_KEY;
return this._saveKey("CUSTOM_CLEANUP_API_KEY", key);
}
// Enterprise providers — AWS Bedrock
getBedrockRegion() {
return this._getKey("BEDROCK_REGION");
}
saveBedrockRegion(value) {
return this._saveKey("BEDROCK_REGION", value);
}
getBedrockProfile() {
return this._getKey("BEDROCK_PROFILE");
}
saveBedrockProfile(value) {
return this._saveKey("BEDROCK_PROFILE", value);
}
getBedrockAccessKeyId() {
return this._getKey("BEDROCK_ACCESS_KEY_ID");
}
saveBedrockAccessKeyId(key) {
return this._saveKey("BEDROCK_ACCESS_KEY_ID", key);
}
getBedrockSecretAccessKey() {
return this._getKey("BEDROCK_SECRET_ACCESS_KEY");
}
saveBedrockSecretAccessKey(key) {
return this._saveKey("BEDROCK_SECRET_ACCESS_KEY", key);
}
getBedrockSessionToken() {
return this._getKey("BEDROCK_SESSION_TOKEN");
}
saveBedrockSessionToken(key) {
return this._saveKey("BEDROCK_SESSION_TOKEN", key);
}
// Enterprise providers — Azure OpenAI
getAzureEndpoint() {
return this._getKey("AZURE_OPENAI_ENDPOINT");
}
saveAzureEndpoint(value) {
return this._saveKey("AZURE_OPENAI_ENDPOINT", value);
}
getAzureApiKey() {
return this._getKey("AZURE_OPENAI_API_KEY");
}
saveAzureApiKey(key) {
return this._saveKey("AZURE_OPENAI_API_KEY", key);
}
getAzureDeployment() {
return this._getKey("AZURE_OPENAI_DEPLOYMENT");
}
saveAzureDeployment(value) {
return this._saveKey("AZURE_OPENAI_DEPLOYMENT", value);
}
getAzureApiVersion() {
return this._getKey("AZURE_OPENAI_API_VERSION");
}
saveAzureApiVersion(value) {
return this._saveKey("AZURE_OPENAI_API_VERSION", value);
}
// Enterprise providers — GCP Vertex AI
getVertexProject() {
return this._getKey("VERTEX_PROJECT");
}
saveVertexProject(value) {
return this._saveKey("VERTEX_PROJECT", value);
}
getVertexLocation() {
return this._getKey("VERTEX_LOCATION");
}
saveVertexLocation(value) {
return this._saveKey("VERTEX_LOCATION", value);
}
getVertexApiKey() {
return this._getKey("VERTEX_API_KEY");
}
saveVertexApiKey(key) {
return this._saveKey("VERTEX_API_KEY", key);
}
getDictationKey() {
return this._getKey("DICTATION_KEY");
}
saveDictationKey(key) {
const result = this._saveKey("DICTATION_KEY", key);
this.saveAllKeysToEnvFile().catch(() => {});
return result;
}
getVoiceAgentKey() {
const key = this._getKey("VOICE_AGENT_KEY");
if (key) return key;
// The chat-agent window is gone; its hotkey now opens the assistant by voice.
const legacy = this._getKey("CHAT_AGENT_KEY");
if (legacy) {
this.saveVoiceAgentKey(legacy);
delete process.env.CHAT_AGENT_KEY;
}
return legacy;
}
saveVoiceAgentKey(key) {
const result = this._saveKey("VOICE_AGENT_KEY", key);
this.saveAllKeysToEnvFile().catch(() => {});
return result;
}
getTranslationKey() {
return this._getKey("TRANSLATION_KEY");
}
saveTranslationKey(key) {
const result = this._saveKey("TRANSLATION_KEY", key);
this.saveAllKeysToEnvFile().catch(() => {});
return result;
}
getMeetingKey() {
return this._getKey("MEETING_KEY");
}
saveMeetingKey(key) {
const result = this._saveKey("MEETING_KEY", key);
this.saveAllKeysToEnvFile().catch(() => {});
return result;
}
getActivationMode() {
const mode = this._getKey("ACTIVATION_MODE");
return mode === "push" ? "push" : "tap";
}
saveActivationMode(mode) {
const validMode = mode === "push" ? "push" : "tap";
const result = this._saveKey("ACTIVATION_MODE", validMode);
this.saveAllKeysToEnvFile().catch(() => {});
return result;
}
getFloatingIconAutoHide() {
return this._getKey("FLOATING_ICON_AUTO_HIDE") === "true";
}
saveFloatingIconAutoHide(enabled) {
const result = this._saveKey("FLOATING_ICON_AUTO_HIDE", String(enabled));
this.saveAllKeysToEnvFile().catch(() => {});
return result;
}
getStartMinimized() {
return this._getKey("START_MINIMIZED") === "true";
}
saveStartMinimized(enabled) {
const result = this._saveKey("START_MINIMIZED", String(enabled));
this.saveAllKeysToEnvFile().catch(() => {});
return result;
}
getPanelStartPosition() {
const v = this._getKey("PANEL_START_POSITION");
if (v === "bottom-right" || v === "center" || v === "bottom-left") return v;
return "bottom-right";
}
savePanelStartPosition(position) {
const result = this._saveKey("PANEL_START_POSITION", position);
this.saveAllKeysToEnvFile().catch(() => {});
return result;
}
getUiLanguage(fallbackLanguage = "") {
const language = this._getKey("UI_LANGUAGE") || fallbackLanguage;
return language ? normalizeUiLanguage(language) : "";
}
saveUiLanguage(language) {
const normalized = normalizeUiLanguage(language);
const result = this._saveKey("UI_LANGUAGE", normalized);
this.saveAllKeysToEnvFile().catch(() => {});
return { ...result, language: normalized };
}
async saveAllKeysToEnvFile() {
const envPath = path.join(app.getPath("userData"), ".env");
await this._writeEnvFileAtomic(envPath);
require("dotenv").config({ path: envPath });
return { success: true, path: envPath };
}
saveDebugLogging(enabled) {
const logLevel = enabled ? "debug" : "info";
const envPath = path.join(app.getPath("userData"), ".env");
// Queue the entire read-modify-write so other saves cannot restore a stale level.
envWriteQueue = envWriteQueue
.catch(() => {})
.then(async () => {
let content = "";
try {
content = await fsPromises.readFile(envPath, "utf8");
} catch (error) {
if (error.code !== "ENOENT") throw error;
}
const lines = content.split("\n");
const logLevelIndex = lines.findIndex((line) =>
line.trim().startsWith("OPENWHISPR_LOG_LEVEL=")
);
const logLevelLine = `OPENWHISPR_LOG_LEVEL=${logLevel}`;
if (logLevelIndex !== -1) {
lines[logLevelIndex] = logLevelLine;
} else {
if (lines[lines.length - 1] !== "") lines.push("");
lines.push(logLevelLine);
}
const tmpPath = `${envPath}.tmp`;
await fsPromises.writeFile(tmpPath, lines.join("\n"), "utf8");
await fsPromises.rename(tmpPath, envPath);
process.env.OPENWHISPR_LOG_LEVEL = logLevel;
});
return envWriteQueue;
}
async clearAllPersistedData() {
for (const envVarName of PERSISTED_KEYS) {
delete process.env[envVarName];
}
delete process.env.CUSTOM_REASONING_API_KEY;
await Promise.all([
fsPromises.rm(path.join(app.getPath("userData"), ".env"), { force: true }),
fsPromises.rm(this._getSecureKeysDir(), { recursive: true, force: true }),
]);
return { success: true };
}
// Removes a single key's line from .env, preserving every other line
// verbatim. saveAllKeysToEnvFile() would instead regenerate the file from
// PERSISTED_KEYS, dropping hand-added lines and materializing session/shell
// env values into the file.
removeKeyFromEnvFile(key) {
const envPath = path.join(app.getPath("userData"), ".env");
envWriteQueue = envWriteQueue.catch(() => {}).then(() => this._removeKeyLine(envPath, key));
return envWriteQueue;
}
async _removeKeyLine(envPath, key) {
let content;
try {
content = await fsPromises.readFile(envPath, "utf8");
} catch {
return; // No .env — nothing to remove.
}
const keyLine = new RegExp(`^\\s*(?:export\\s+)?${key}\\s*=`);
const lines = content.split("\n");
const kept = lines.filter((line) => !keyLine.test(line));
if (kept.length === lines.length) return;
const tmpPath = `${envPath}.tmp`;
await fsPromises.writeFile(tmpPath, kept.join("\n"), "utf8");
await fsPromises.rename(tmpPath, envPath);
}
}
// Generate the uniform BYOK key accessors (getOpenAIKey/saveOpenAIKey/…) from
// the shared manifest so each provider is defined in exactly one place.
for (const k of BYOK_API_KEYS) {
EnvironmentManager.prototype[k.get] = function () {
return this._getKey(k.env);
};
EnvironmentManager.prototype[k.save] = function (key) {
return this._saveKey(k.env, key);
};
}
module.exports = EnvironmentManager;