Speakr is a personal, self-hosted web application designed for transcribing audio recordings
Python
Add IndexedDB recording persistence and crash recovery
Murtaza Nasirce030bbbfceb
diff --git a/static/js/app.modular.js b/static/js/app.modular.jsindex d444a8a1..69495134 100644--- a/static/js/app.modular.js+++ b/static/js/app.modular.js@@ -156,6 +156,8 @@ document.addEventListener('DOMContentLoaded', async () => {const recordingNotes = ref('');const showSystemAudioHelp = ref(false);const showSystemAudioHelpModal = ref(false);+ const showRecoveryModal = ref(false);+ const recoverableRecording = ref(null);const asrLanguage = ref('');const asrMinSpeakers = ref('');const asrMaxSpeakers = ref('');@@ -1247,6 +1249,18 @@ document.addEventListener('DOMContentLoaded', async () => {uiComposable.initializeColorScheme();uiComposable.initializeSidebar();+ // Check for recoverable recording from IndexedDB+ try {+ const recoverable = await audioComposable.checkForRecoverableRecording();+ if (recoverable && recoverable.chunks && recoverable.chunks.length > 0) {+ recoverableRecording.value = recoverable;+ showRecoveryModal.value = true;+ console.log('[App] Found recoverable recording, showing recovery dialog');+ }+ } catch (error) {+ console.error('[App] Failed to check for recoverable recording:', error);+ }+// Load initial dataawait Promise.all([recordingsComposable.loadRecordings(),@@ -1318,6 +1332,52 @@ document.addEventListener('DOMContentLoaded', async () => {});});+ // =========================================================================+ // RECORDING RECOVERY FUNCTIONS+ // =========================================================================++ const recoverRecording = async () => {+ try {+ showRecoveryModal.value = false;++ const recovered = await audioComposable.recoverRecordingFromDB();+ if (recovered) {+ currentView.value = 'preview';+ showToast('Recording recovered successfully', 'success');+ } else {+ showToast('Failed to recover recording', 'error');+ }++ recoverableRecording.value = null;+ } catch (error) {+ console.error('[App] Failed to recover recording:', error);+ showToast('Error recovering recording', 'error');+ }+ };++ const cancelRecovery = async () => {+ try {+ showRecoveryModal.value = false;++ // Clear the recording from IndexedDB+ await audioComposable.clearRecordingSession();++ showToast('Recording discarded', 'info');+ recoverableRecording.value = null;+ } catch (error) {+ console.error('[App] Failed to discard recording:', error);+ }+ };++ const formatRecordingMode = (mode) => {+ const modes = {+ 'microphone': t('recording.modeMicrophone'),+ 'system': t('recording.modeSystem'),+ 'both': t('recording.modeBoth')+ };+ return modes[mode] || mode;+ };+// =========================================================================// WATCHERS// =========================================================================@@ -1374,6 +1434,13 @@ document.addEventListener('DOMContentLoaded', async () => {showToast,getContrastTextColor,getBubbleGlobalIndex,+ formatRecordingMode,++ // Recording recovery+ showRecoveryModal,+ recoverableRecording,+ recoverRecording,+ cancelRecovery,// Composable methods...recordingsComposable,diff --git a/static/js/modules/composables/audio.js b/static/js/modules/composables/audio.jsindex f86fc9c0..f4972aaa 100644--- a/static/js/modules/composables/audio.js+++ b/static/js/modules/composables/audio.js@@ -3,6 +3,8 @@* Handles microphone/system audio recording with visualizers and wake lock*/+import * as RecordingDB from '../db/recording-persistence.js';+export function useAudio(state, utils) {const {isRecording, mediaRecorder, audioContext, analyser, micAnalyser, systemAnalyser,@@ -177,6 +179,9 @@ export function useAudio(state, utils) {estimatedFileSize.value = 0;fileSizeWarningShown.value = false;+ // Initialize IndexedDB session+ state.currentChunkIndex = 0;+let stream;let combinedStream;@@ -302,9 +307,38 @@ export function useAudio(state, utils) {const recorder = new MediaRecorder(stream, { mimeType });- recorder.ondataavailable = (event) => {+ // Start IndexedDB recording session+ try {+ await RecordingDB.startRecordingSession({+ mode,+ notes: recordingNotes.value,+ tags: selectedTagIds.value,+ asrOptions: {+ language: asrLanguage.value,+ min_speakers: asrMinSpeakers.value,+ max_speakers: asrMaxSpeakers.value+ },+ mimeType+ });+ } catch (dbError) {+ console.warn('[Recording] IndexedDB persistence failed, continuing without persistence:', dbError);+ }++ recorder.ondataavailable = async (event) => {if (event.data.size > 0) {audioChunks.value.push(event.data);++ // Save chunk to IndexedDB for crash recovery+ try {+ await RecordingDB.saveChunk(event.data, state.currentChunkIndex);+ await RecordingDB.updateRecordingMetadata({+ duration: recordingTime.value,+ notes: recordingNotes.value+ });+ state.currentChunkIndex++;+ } catch (dbError) {+ console.warn('[Recording] Failed to save chunk to IndexedDB:', dbError);+ }}};@@ -402,7 +436,7 @@ export function useAudio(state, utils) {};// Upload recorded audio- const uploadRecordedAudio = () => {+ const uploadRecordedAudio = async () => {if (!audioBlobURL.value) {setGlobalError("No recorded audio to upload.");return;@@ -436,6 +470,13 @@ export function useAudio(state, utils) {willAutoSummarize: false // Server will tell us via SUMMARIZING status});+ // Clear IndexedDB session after successful queue+ try {+ await RecordingDB.clearRecordingSession();+ } catch (dbError) {+ console.warn('[Recording] Failed to clear IndexedDB session:', dbError);+ }+discardRecording();// Return to upload view (main UI)@@ -466,6 +507,13 @@ export function useAudio(state, utils) {asrMinSpeakers.value = '';asrMaxSpeakers.value = '';+ // Clear IndexedDB session+ try {+ await RecordingDB.clearRecordingSession();+ } catch (dbError) {+ console.warn('[Recording] Failed to clear IndexedDB session:', dbError);+ }+await releaseWakeLock();await hideRecordingNotification();};@@ -586,6 +634,41 @@ export function useAudio(state, utils) {return isRecording.value || audioBlobURL.value;};+ // Recover recording from IndexedDB+ const recoverRecordingFromDB = async () => {+ try {+ const recovered = await RecordingDB.recoverRecording();+ if (!recovered) {+ return null;+ }++ // Restore chunks+ audioChunks.value = recovered.chunks;++ // Create blob URL+ const blob = new Blob(recovered.chunks, { type: recovered.metadata.mimeType });+ audioBlobURL.value = URL.createObjectURL(blob);++ // Restore metadata+ recordingMode.value = recovered.metadata.mode;+ recordingNotes.value = recovered.metadata.notes;+ selectedTagIds.value = recovered.metadata.tags;+ recordingTime.value = recovered.metadata.duration;++ if (recovered.metadata.asrOptions) {+ asrLanguage.value = recovered.metadata.asrOptions.language || '';+ asrMinSpeakers.value = recovered.metadata.asrOptions.min_speakers || '';+ asrMaxSpeakers.value = recovered.metadata.asrOptions.max_speakers || '';+ }++ console.log('[Recording] Successfully recovered recording from IndexedDB');+ return recovered.metadata;+ } catch (error) {+ console.error('[Recording] Failed to recover recording:', error);+ return null;+ }+ };+// No initialization needed - system audio detection is handled by computed propertyconst initializeAudio = async () => {// Placeholder for future initialization if needed@@ -607,6 +690,9 @@ export function useAudio(state, utils) {hasUnsavedRecording,acquireWakeLock,releaseWakeLock,- initializeAudio+ initializeAudio,+ recoverRecordingFromDB,+ checkForRecoverableRecording: RecordingDB.checkForRecoverableRecording,+ clearRecordingSession: RecordingDB.clearRecordingSession};}diff --git a/static/js/modules/db/recording-persistence.js b/static/js/modules/db/recording-persistence.jsnew file mode 100644index 00000000..b7f8531d--- /dev/null+++ b/static/js/modules/db/recording-persistence.js@@ -0,0 +1,257 @@+/**+ * IndexedDB Recording Persistence+ * Handles saving recording chunks to IndexedDB for crash recovery+ */++const DB_NAME = 'SpeakrRecordings';+const DB_VERSION = 1;+const STORE_NAME = 'activeRecording';++let dbInstance = null;++/**+ * Initialize IndexedDB+ */+export const initDB = () => {+ return new Promise((resolve, reject) => {+ if (dbInstance) {+ resolve(dbInstance);+ return;+ }++ const request = indexedDB.open(DB_NAME, DB_VERSION);++ request.onerror = () => {+ console.error('[RecordingDB] Failed to open database:', request.error);+ reject(request.error);+ };++ request.onsuccess = () => {+ dbInstance = request.result;+ console.log('[RecordingDB] Database opened successfully');+ resolve(dbInstance);+ };++ request.onupgradeneeded = (event) => {+ const db = event.target.result;++ // Create object store for active recording+ if (!db.objectStoreNames.contains(STORE_NAME)) {+ const objectStore = db.createObjectStore(STORE_NAME, { keyPath: 'id' });+ objectStore.createIndex('timestamp', 'timestamp', { unique: false });+ console.log('[RecordingDB] Object store created');+ }+ };+ });+};++/**+ * Save recording metadata and initialize session+ */+export const startRecordingSession = async (recordingData) => {+ try {+ const db = await initDB();+ const transaction = db.transaction([STORE_NAME], 'readwrite');+ const objectStore = transaction.objectStore(STORE_NAME);++ const session = {+ id: 'current',+ timestamp: Date.now(),+ startTime: new Date().toISOString(),+ mode: recordingData.mode,+ notes: recordingData.notes || '',+ tags: recordingData.tags || [],+ asrOptions: recordingData.asrOptions || {},+ chunks: [],+ mimeType: recordingData.mimeType || 'audio/webm',+ duration: 0+ };++ await objectStore.put(session);+ console.log('[RecordingDB] Recording session started:', session.id);+ return session;+ } catch (error) {+ console.error('[RecordingDB] Failed to start session:', error);+ throw error;+ }+};++/**+ * Save a recording chunk to IndexedDB+ */+export const saveChunk = async (chunkBlob, chunkIndex) => {+ try {+ const db = await initDB();+ const transaction = db.transaction([STORE_NAME], 'readwrite');+ const objectStore = transaction.objectStore(STORE_NAME);++ // Get current session+ const session = await objectStore.get('current');++ if (!session) {+ console.warn('[RecordingDB] No active session found');+ return;+ }++ // Convert Blob to ArrayBuffer for storage+ const arrayBuffer = await chunkBlob.arrayBuffer();++ // Add chunk to session+ session.chunks.push({+ index: chunkIndex,+ data: arrayBuffer,+ size: chunkBlob.size,+ timestamp: Date.now()+ });++ // Update session+ await objectStore.put(session);+ console.log(`[RecordingDB] Chunk ${chunkIndex} saved (${chunkBlob.size} bytes)`);+ } catch (error) {+ console.error('[RecordingDB] Failed to save chunk:', error);+ // Don't throw - recording should continue even if persistence fails+ }+};++/**+ * Update recording metadata (notes, duration, etc.)+ */+export const updateRecordingMetadata = async (updates) => {+ try {+ const db = await initDB();+ const transaction = db.transaction([STORE_NAME], 'readwrite');+ const objectStore = transaction.objectStore(STORE_NAME);++ const session = await objectStore.get('current');++ if (!session) {+ console.warn('[RecordingDB] No active session to update');+ return;+ }++ // Merge updates+ Object.assign(session, updates);+ await objectStore.put(session);++ console.log('[RecordingDB] Metadata updated:', updates);+ } catch (error) {+ console.error('[RecordingDB] Failed to update metadata:', error);+ }+};++/**+ * Check if there's a recoverable recording+ */+export const checkForRecoverableRecording = async () => {+ try {+ const db = await initDB();+ const transaction = db.transaction([STORE_NAME], 'readonly');+ const objectStore = transaction.objectStore(STORE_NAME);++ const session = await objectStore.get('current');++ if (!session || !session.chunks || session.chunks.length === 0) {+ return null;+ }++ // Calculate total size+ const totalSize = session.chunks.reduce((sum, chunk) => sum + chunk.size, 0);++ // Calculate approximate duration (1 second chunks)+ const duration = session.chunks.length;++ console.log('[RecordingDB] Found recoverable recording:', {+ chunks: session.chunks.length,+ size: totalSize,+ duration: duration,+ startTime: session.startTime+ });++ return {+ ...session,+ totalSize,+ duration: duration+ };+ } catch (error) {+ console.error('[RecordingDB] Failed to check for recoverable recording:', error);+ return null;+ }+};++/**+ * Recover recording from IndexedDB+ */+export const recoverRecording = async () => {+ try {+ const db = await initDB();+ const transaction = db.transaction([STORE_NAME], 'readonly');+ const objectStore = transaction.objectStore(STORE_NAME);++ const session = await objectStore.get('current');++ if (!session || !session.chunks || session.chunks.length === 0) {+ console.warn('[RecordingDB] No recording to recover');+ return null;+ }++ // Convert chunks back to Blobs+ const chunks = session.chunks.map(chunk => {+ return new Blob([chunk.data], { type: session.mimeType });+ });++ console.log(`[RecordingDB] Recovered ${chunks.length} chunks`);++ return {+ chunks,+ metadata: {+ mode: session.mode,+ notes: session.notes,+ tags: session.tags,+ asrOptions: session.asrOptions,+ mimeType: session.mimeType,+ duration: session.chunks.length,+ startTime: session.startTime+ }+ };+ } catch (error) {+ console.error('[RecordingDB] Failed to recover recording:', error);+ return null;+ }+};++/**+ * Clear recording session (after successful upload or discard)+ */+export const clearRecordingSession = async () => {+ try {+ const db = await initDB();+ const transaction = db.transaction([STORE_NAME], 'readwrite');+ const objectStore = transaction.objectStore(STORE_NAME);++ await objectStore.delete('current');+ console.log('[RecordingDB] Recording session cleared');+ } catch (error) {+ console.error('[RecordingDB] Failed to clear session:', error);+ }+};++/**+ * Get database size information+ */+export const getDatabaseSize = async () => {+ try {+ if (!navigator.storage || !navigator.storage.estimate) {+ return null;+ }++ const estimate = await navigator.storage.estimate();+ return {+ usage: estimate.usage,+ quota: estimate.quota,+ percentage: ((estimate.usage / estimate.quota) * 100).toFixed(2)+ };+ } catch (error) {+ console.error('[RecordingDB] Failed to get database size:', error);+ return null;+ }+};diff --git a/static/locales/en.json b/static/locales/en.jsonindex 30b97d1f..ed850698 100644--- a/static/locales/en.json+++ b/static/locales/en.json@@ -759,19 +759,31 @@"acceptDisclaimer": "I Accept","cancelRecording": "Cancel","disclaimer": "Recording Disclaimer",+ "discardRecovery": "Discard",+ "duration": "Duration","microphone": "Microphone","microphoneAndSystem": "Microphone + System","microphonePermissionDenied": "Microphone permission denied",+ "modeBoth": "Microphone + System",+ "modeMicrophone": "Microphone",+ "modeSystem": "System Audio","notes": "Notes","notesPlaceholder": "Add notes about this recording...","pauseRecording": "Pause","recordingFailed": "Recording failed","recordingInProgress": "Recording in progress...",+ "recordingMode": "Recording Mode","recordingSize": "Estimated Size","recordingStopped": "Recording stopped","recordingTime": "Recording Time",+ "recoveryDescription": "We found an unfinished recording from a previous session. Would you like to restore it?",+ "recoveryFound": "Unsaved Recording Detected",+ "recoveryTitle": "Recover Recording",+ "restoreRecording": "Restore","resumeRecording": "Resume","saveRecording": "Save Recording",+ "size": "Size",+ "startedAt": "Started At","startRecording": "Start Recording","stopRecording": "Stop Recording","systemAudio": "System Audio",diff --git a/templates/index.html b/templates/index.htmlindex 9d84eb22..9d8a06eb 100644--- a/templates/index.html+++ b/templates/index.html@@ -96,6 +96,7 @@{% include 'modals/edit-participants-modal.html' %}{% include 'modals/color-scheme-modal.html' %}{% include 'modals/system-audio-help-modal.html' %}+ {% include 'modals/recording-recovery-modal.html' %}{% include 'modals/unified-share-modal.html' %}{% include 'modals/share-delete-modal.html' %}{% include 'modals/global-error.html' %}diff --git a/templates/modals/recording-recovery-modal.html b/templates/modals/recording-recovery-modal.htmlnew file mode 100644index 00000000..d0f36512--- /dev/null+++ b/templates/modals/recording-recovery-modal.html@@ -0,0 +1,59 @@+<!-- Recording Recovery Modal -->+<div v-if="showRecoveryModal" @click="cancelRecovery" class="fixed inset-0 bg-black bg-opacity-70 flex items-center justify-center z-50 p-4 backdrop-blur-sm">+ <div @click.stop class="bg-[var(--bg-secondary)] rounded-xl shadow-2xl w-full max-w-md">+ <div class="p-6 border-b border-[var(--border-primary)]">+ <div class="flex items-center gap-3">+ <i class="fas fa-history text-2xl text-blue-500"></i>+ <h3 class="text-lg font-semibold" v-text="t('recording.recoveryTitle')"></h3>+ </div>+ </div>++ <div class="p-6 space-y-4">+ <div class="p-4 bg-blue-50 dark:bg-blue-900/20 border border-blue-200 dark:border-blue-800 rounded-lg">+ <div class="flex items-start gap-3">+ <i class="fas fa-info-circle text-blue-600 dark:text-blue-400 mt-0.5"></i>+ <div class="text-sm text-blue-700 dark:text-blue-400">+ <p class="font-medium mb-1">{{ t('recording.recoveryFound') }}</p>+ <p>{{ t('recording.recoveryDescription') }}</p>+ </div>+ </div>+ </div>++ <div v-if="recoverableRecording" class="space-y-2 text-sm">+ <div class="flex justify-between">+ <span class="text-[var(--text-muted)]">{{ t('recording.recordingMode') }}:</span>+ <span class="font-medium">{{ formatRecordingMode(recoverableRecording.mode) }}</span>+ </div>+ <div class="flex justify-between">+ <span class="text-[var(--text-muted)]">{{ t('recording.duration') }}:</span>+ <span class="font-medium">{{ formatTime(recoverableRecording.duration) }}</span>+ </div>+ <div class="flex justify-between">+ <span class="text-[var(--text-muted)]">{{ t('recording.size') }}:</span>+ <span class="font-medium">{{ formatFileSize(recoverableRecording.totalSize) }}</span>+ </div>+ <div class="flex justify-between">+ <span class="text-[var(--text-muted)]">{{ t('recording.startedAt') }}:</span>+ <span class="font-medium">{{ formatDateTime(recoverableRecording.startTime) }}</span>+ </div>+ <div v-if="recoverableRecording.notes" class="pt-2 border-t border-[var(--border-secondary)]">+ <span class="text-[var(--text-muted)]">{{ t('recording.notes') }}:</span>+ <p class="mt-1 text-[var(--text-primary)]">{{ recoverableRecording.notes }}</p>+ </div>+ </div>+ </div>++ <div class="p-6 border-t border-[var(--border-primary)] flex gap-3">+ <button+ @click="cancelRecovery"+ class="flex-1 px-4 py-2.5 bg-[var(--bg-tertiary)] text-[var(--text-primary)] rounded-lg hover:bg-[var(--bg-hover)] transition-colors font-medium">+ <i class="fas fa-trash mr-2"></i>{{ t('recording.discardRecovery') }}+ </button>+ <button+ @click="recoverRecording"+ class="flex-1 px-4 py-2.5 bg-blue-600 text-white rounded-lg hover:bg-blue-700 transition-colors font-medium">+ <i class="fas fa-undo mr-2"></i>{{ t('recording.restoreRecording') }}+ </button>+ </div>+ </div>+</div>