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 { autoUpdater } = require("electron-updater");
// electron-updater can only replace an AppImage on Linux; deb, rpm and tar.gz
// installs are updated by the package manager instead.
const isUpdaterSupported = process.platform !== "linux" || Boolean(process.env.APPIMAGE);
class UpdateManager {
constructor() {
this.updateAvailable = false;
this.updateDownloaded = false;
this.lastUpdateInfo = null;
this.isInstalling = false;
this.isDownloading = false;
this.isQuittingForUpdate = false;
this.handleBeforeQuitForUpdate = null;
this.eventListeners = [];
this.updateCheckInterval = null;
this.windowManager = null;
// null until the renderer syncs the preference, so nothing downloads unasked.
this.autoUpdatesEnabled = null;
this.setupAutoUpdater();
}
setWindowManager(windowManager) {
this.windowManager = windowManager;
}
setupAutoUpdater() {
if (process.env.NODE_ENV === "development") {
return;
}
autoUpdater.setFeedURL({
provider: "github",
owner: "OpenWhispr",
repo: "openwhispr",
private: false,
});
// Use arch-specific update channel on macOS to prevent arm64/x64
// from downloading mismatched artifacts. Both builds publish to the
// same GitHub release, so without this they race on latest-mac.yml.
// Setting channel to e.g. 'latest-arm64' makes the updater look for
// 'latest-arm64-mac.yml' instead of the shared 'latest-mac.yml'.
if (process.platform === "darwin") {
let nativeArch = process.arch;
// Detect Rosetta: if an x64 build is running on Apple Silicon,
// sysctl.proc_translated returns "1". This self-heals users who
// got stuck on the x64 build from older releases.
if (process.arch === "x64") {
try {
const { execSync } = require("child_process");
const translated = execSync("sysctl -n sysctl.proc_translated", {
encoding: "utf8",
timeout: 3000,
}).trim();
if (translated === "1") {
console.log("π Rosetta detected β switching update channel to arm64");
nativeArch = "arm64";
}
} catch {
// sysctl.proc_translated doesn't exist on real Intel Macs β ignore
}
}
autoUpdater.channel = nativeArch === "arm64" ? "latest-arm64" : "latest-x64";
}
autoUpdater.autoDownload = false;
autoUpdater.autoInstallOnAppQuit = true;
autoUpdater.logger = console;
this.setupEventHandlers();
}
setupEventHandlers() {
const handlers = {
"checking-for-update": () => {
this.notifyRenderers("checking-for-update");
},
"update-available": (info) => {
this.updateAvailable = true;
if (info) {
this.lastUpdateInfo = {
version: info.version,
releaseDate: info.releaseDate,
releaseNotes: info.releaseNotes,
files: info.files,
};
}
this.notifyRenderers("update-available", info);
this._autoDownloadIfEnabled();
},
"update-not-available": (info) => {
this.updateAvailable = false;
if (!this.updateDownloaded) {
this.isDownloading = false;
this.lastUpdateInfo = null;
}
this.notifyRenderers("update-not-available", info);
},
error: (err) => {
console.error("β Auto-updater error:", err);
this.isDownloading = false;
this.notifyRenderers("update-error", err);
},
"download-progress": (progressObj) => {
console.log(
`π₯ Download progress: ${progressObj.percent.toFixed(2)}% (${(progressObj.transferred / 1024 / 1024).toFixed(2)}MB / ${(progressObj.total / 1024 / 1024).toFixed(2)}MB)`
);
this.notifyRenderers("update-download-progress", progressObj);
},
"update-downloaded": (info) => {
console.log("β
Update downloaded successfully:", info?.version);
this.updateDownloaded = true;
this.isDownloading = false;
if (info) {
this.lastUpdateInfo = {
version: info.version,
releaseDate: info.releaseDate,
releaseNotes: info.releaseNotes,
files: info.files,
};
}
this.notifyRenderers("update-downloaded", info);
},
};
Object.entries(handlers).forEach(([event, handler]) => {
autoUpdater.on(event, handler);
this.eventListeners.push({ event, handler });
});
// electron-updater and Squirrel.Mac emit this on Electron's native
// autoUpdater (before any windows close), not on the electron-updater instance.
this.handleBeforeQuitForUpdate = () => {
this.isQuittingForUpdate = true;
if (this.windowManager) {
this.windowManager.isQuitting = true;
this.windowManager.hotkeyManager.unregisterAll();
}
};
require("electron").autoUpdater.on("before-quit-for-update", this.handleBeforeQuitForUpdate);
}
notifyRenderers(channel, data) {
// Read window refs live from windowManager: cached refs go stale when the
// control panel is created after boot (start minimized) or recreated.
const { mainWindow, controlPanelWindow } = this.windowManager ?? {};
for (const win of [mainWindow, controlPanelWindow]) {
if (win && !win.isDestroyed() && win.webContents) {
win.webContents.send(channel, data);
}
}
}
async checkForUpdates() {
try {
if (process.env.NODE_ENV === "development") {
return {
updateAvailable: false,
message: "Update checks are disabled in development mode",
};
}
if (!isUpdaterSupported) {
return {
updateAvailable: false,
message: "Updates are installed through the system package manager",
};
}
console.log("π Checking for updates...");
const result = await autoUpdater.checkForUpdates();
if (result?.isUpdateAvailable && result?.updateInfo) {
console.log("π Update available:", result.updateInfo.version);
return {
updateAvailable: true,
version: result.updateInfo.version,
releaseDate: result.updateInfo.releaseDate,
files: result.updateInfo.files,
releaseNotes: result.updateInfo.releaseNotes,
};
} else {
console.log("β
Already on latest version");
return {
updateAvailable: false,
message: "You are running the latest version",
};
}
} catch (error) {
console.error("β Update check error:", error);
throw error;
}
}
async downloadUpdate() {
try {
if (process.env.NODE_ENV === "development") {
return {
success: false,
message: "Update downloads are disabled in development mode",
};
}
if (this.isDownloading) {
return {
success: true,
message: "Download already in progress",
};
}
if (this.updateDownloaded) {
return {
success: true,
message: "Update already downloaded. Ready to install.",
};
}
this.isDownloading = true;
console.log("π₯ Starting update download...");
await autoUpdater.downloadUpdate();
console.log("π₯ Download initiated successfully");
return { success: true, message: "Update download started" };
} catch (error) {
this.isDownloading = false;
console.error("β Update download error:", error);
throw error;
}
}
async installUpdate() {
try {
if (process.env.NODE_ENV === "development") {
return {
success: false,
message: "Update installation is disabled in development mode",
};
}
if (!this.updateDownloaded) {
return {
success: false,
message: "No update available to install",
};
}
if (this.isInstalling) {
return {
success: false,
message: "Update installation already in progress",
};
}
this.isInstalling = true;
console.log("π Installing update and restarting...");
const isSilent = process.platform === "win32";
autoUpdater.quitAndInstall(isSilent, true);
return { success: true, message: "Update installation started" };
} catch (error) {
this.isInstalling = false;
console.error("β Update installation error:", error);
throw error;
}
}
async getAppVersion() {
try {
const { app } = require("electron");
return { version: app.getVersion() };
} catch (error) {
console.error("β Error getting app version:", error);
throw error;
}
}
async getUpdateStatus() {
try {
return {
updateAvailable: this.updateAvailable,
updateDownloaded: this.updateDownloaded,
isDevelopment: process.env.NODE_ENV === "development",
isSupported: isUpdaterSupported,
};
} catch (error) {
console.error("β Error getting update status:", error);
throw error;
}
}
async getUpdateInfo() {
try {
return this.lastUpdateInfo;
} catch (error) {
console.error("β Error getting update info:", error);
throw error;
}
}
setAutoUpdatesEnabled(enabled) {
this.autoUpdatesEnabled = enabled;
// The startup check may have found an update before the renderer synced.
if (enabled) this._autoDownloadIfEnabled();
}
// NSIS and AppImage install a downloaded update from their quit handler, which would
// replace the executable a reset relaunch starts (an AppImage even moves to a new
// file name).
deferInstallOnQuit() {
autoUpdater.autoInstallOnAppQuit = false;
}
// On macOS a finished download is handed to Squirrel.Mac, which installs it on any
// quit from then on; MacUpdater records that hand-off in squirrelDownloadedUpdate.
hasStagedUpdate() {
return process.platform === "darwin" && autoUpdater.squirrelDownloadedUpdate === true;
}
_autoDownloadIfEnabled() {
if (!this.autoUpdatesEnabled || !this.updateAvailable) return;
// downloadUpdate() is a no-op while a download is in flight or complete;
// failures surface through the shared "error" handler and the renderers.
this.downloadUpdate().catch(() => {});
}
// Checks always run so the sidebar can offer a manual download when automatic
// updates are off; a failed background check is logged and never surfaced.
_autoCheckForUpdates(label) {
console.log(`π ${label} update check...`);
autoUpdater.checkForUpdates().catch((err) => {
console.error(`${label} update check failed:`, err);
});
}
checkForUpdatesOnStartup() {
if (process.env.NODE_ENV !== "development" && isUpdaterSupported) {
setTimeout(() => {
this._autoCheckForUpdates("Startup");
}, 3000);
const FOUR_HOURS_MS = 4 * 60 * 60 * 1000;
this.updateCheckInterval = setInterval(() => {
this._autoCheckForUpdates("Periodic");
}, FOUR_HOURS_MS);
}
}
cleanup() {
if (this.updateCheckInterval) {
clearInterval(this.updateCheckInterval);
this.updateCheckInterval = null;
}
this.eventListeners.forEach(({ event, handler }) => {
autoUpdater.removeListener(event, handler);
});
this.eventListeners = [];
if (this.handleBeforeQuitForUpdate) {
require("electron").autoUpdater.removeListener(
"before-quit-for-update",
this.handleBeforeQuitForUpdate
);
this.handleBeforeQuitForUpdate = null;
}
}
}
module.exports = UpdateManager;