Skip to content

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.js
index 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 data
await 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.js
index 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 property
const 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.js
new file mode 100644
index 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.json
index 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.html
index 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.html
new file mode 100644
index 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>