listener-ai 2.0.0 → 2.1.1

package/dist/agentService.js

@@ -234,7 +234,7 @@ class AgentService {
         const tools = buildTools(opts.scope, !!opts.confirm);
         // Load the single-meeting record once if needed; title + primer derive from it.
         const singleData = opts.scope.kind === 'single' && isValidFolderName(opts.scope.folderName)
-            ? (0, outputService_1.readTranscription)(path.join((0, outputService_1.getTranscriptionsDir)(this.dataPath), opts.scope.folderName))
+            ? await (0, outputService_1.readTranscription)(path.join((0, outputService_1.getTranscriptionsDir)(this.dataPath), opts.scope.folderName))
             : null;
         const systemInstruction = systemInstructionFor(opts.scope, singleData?.title);
         const history = opts.history ? [...opts.history] : [];
@@ -305,7 +305,7 @@ class AgentService {
                     const limit = typeof args.limit === 'number' ? args.limit : 5;
                     const includeTranscript = args.include_transcript === true;
                     const fields = includeTranscript ? [...searchService_1.ALL_FIELDS] : ['title', 'summary', 'keyPoints', 'actionItems'];
-                    const hits = (0, searchService_1.searchTranscriptions)(this.dataPath, { query, fields, limit });
+                    const hits = await (0, searchService_1.searchTranscriptions)(this.dataPath, { query, fields, limit });
                     return {
                         hits: hits.map((h) => ({
                             folder_name: h.entry.folderName,
@@ -319,7 +319,7 @@ class AgentService {
                 }
                 case 'list_recent_transcriptions': {
                     const limit = typeof args.limit === 'number' ? args.limit : 10;
-                    const entries = (0, outputService_1.listTranscriptions)(this.dataPath, limit);
+                    const entries = await (0, outputService_1.listTranscriptions)(this.dataPath, limit);
                     return {
                         entries: entries.map((e) => ({
                             folder_name: e.folderName,
@@ -333,7 +333,7 @@ class AgentService {
                     if (!isValidFolderName(folderName))
                         return { error: 'folder_name must be a bare folder name returned by search/list (no slashes, no ..)' };
                     const folderPath = path.join((0, outputService_1.getTranscriptionsDir)(this.dataPath), folderName);
-                    const data = (0, outputService_1.readTranscription)(folderPath);
+                    const data = await (0, outputService_1.readTranscription)(folderPath);
                     if (!data)
                         return { error: `transcription not found: ${folderName}` };
                     const result = {

package/dist/cli.js

@@ -155,10 +155,10 @@ function handleConfig(subArgs) {
     process.stderr.write(`Error: Unknown config command: ${sub}\n`);
     usage();
 }
-function resolveRef(ref, dataPath) {
+async function resolveRef(ref, dataPath) {
     if (/^\d+$/.test(ref)) {
         const index = parseInt(ref, 10);
-        const entries = (0, outputService_1.listTranscriptions)(dataPath, 0);
+        const entries = await (0, outputService_1.listTranscriptions)(dataPath, 0);
         if (entries.length === 0) {
             process.stderr.write('Error: No transcriptions found.\n');
             process.exit(1);
@@ -176,7 +176,7 @@ function resolveRef(ref, dataPath) {
     }
     return folderPath;
 }
-function handleList(args) {
+async function handleList(args) {
     const dataPath = (0, dataPath_1.getDataPath)();
     let limit;
     for (let i = 0; i < args.length; i++) {
@@ -188,7 +188,7 @@ function handleList(args) {
             }
         }
     }
-    const entries = (0, outputService_1.listTranscriptions)(dataPath, limit);
+    const entries = await (0, outputService_1.listTranscriptions)(dataPath, limit);
     if (entries.length === 0) {
         process.stderr.write('No transcriptions found.\n');
         return;
@@ -202,14 +202,14 @@ function handleList(args) {
         process.stdout.write(`${num}  ${date}  ${title}\n`);
     }
 }
-function handleShow(args) {
+async function handleShow(args) {
     const ref = args[0];
     if (!ref) {
         process.stderr.write('Error: Missing ref. Usage: listener show <ref>\n');
         process.exit(1);
     }
     const dataPath = (0, dataPath_1.getDataPath)();
-    const folderPath = resolveRef(ref, dataPath);
+    const folderPath = await resolveRef(ref, dataPath);
     const summaryPath = path.join(folderPath, 'summary.md');
     if (!fs.existsSync(summaryPath)) {
         process.stderr.write(`Error: summary.md not found in ${folderPath}\n`);
@@ -219,7 +219,7 @@ function handleShow(args) {
     const { body } = (0, outputService_1.parseFrontmatter)(content);
     process.stdout.write(body);
 }
-function handleExport(args) {
+async function handleExport(args) {
     let ref;
     let targetPath;
     let json = false;
@@ -251,7 +251,7 @@ function handleExport(args) {
         process.exit(1);
     }
     const dataPath = (0, dataPath_1.getDataPath)();
-    const folderPath = resolveRef(ref, dataPath);
+    const folderPath = await resolveRef(ref, dataPath);
     const summaryPath = path.join(folderPath, 'summary.md');
     if (!fs.existsSync(summaryPath)) {
         process.stderr.write(`Error: summary.md not found in ${folderPath}\n`);
@@ -310,7 +310,7 @@ function handleExport(args) {
         }
     }
 }
-function handleSearch(args) {
+async function handleSearch(args) {
     const VALID_FIELDS = [...searchService_1.ALL_FIELDS, 'all'];
     let query;
     let limit = 20;
@@ -357,7 +357,7 @@ function handleSearch(args) {
     }
     const dataPath = (0, dataPath_1.getDataPath)();
     const fields = (0, searchService_1.resolveFields)({ field, includeTranscript });
-    const hits = (0, searchService_1.searchTranscriptions)(dataPath, { query, fields, limit });
+    const hits = await (0, searchService_1.searchTranscriptions)(dataPath, { query, fields, limit });
     if (hits.length === 0) {
         process.stderr.write('No results.\n');
         return;
@@ -421,7 +421,7 @@ async function handleAsk(args) {
     }
     let scope = { kind: 'all' };
     if (ref) {
-        const folderPath = resolveRef(ref, dataPath);
+        const folderPath = await resolveRef(ref, dataPath);
         scope = { kind: 'single', folderName: path.basename(folderPath) };
     }
     const agent = new agentService_1.AgentService({ apiKey, dataPath, configService: config });
@@ -448,19 +448,19 @@ async function main() {
         return;
     }
     if (args[0] === 'list') {
-        handleList(args.slice(1));
+        await handleList(args.slice(1));
         return;
     }
     if (args[0] === 'show') {
-        handleShow(args.slice(1));
+        await handleShow(args.slice(1));
         return;
     }
     if (args[0] === 'export') {
-        handleExport(args.slice(1));
+        await handleExport(args.slice(1));
         return;
     }
     if (args[0] === 'search') {
-        handleSearch(args.slice(1));
+        await handleSearch(args.slice(1));
         return;
     }
     if (args[0] === 'ask') {

package/dist/configService.js

@@ -194,6 +194,9 @@ class ConfigService {
         this.config.minRecordingSeconds = Math.max(0, Math.floor(seconds));
         this.saveConfig();
     }
+    getAudioDeviceId() {
+        return this.config.audioDeviceId;
+    }
     getLastSeenVersion() {
         return this.config.lastSeenVersion;
     }
@@ -232,6 +235,7 @@ class ConfigService {
             maxRecordingMinutes: this.getMaxRecordingMinutes(),
             recordingReminderMinutes: this.getRecordingReminderMinutes(),
             minRecordingSeconds: this.getMinRecordingSeconds(),
+            audioDeviceId: this.getAudioDeviceId(),
             lastSeenVersion: this.getLastSeenVersion()
         };
     }

package/dist/geminiService.js

@@ -38,6 +38,7 @@ const genai_1 = require("@google/genai");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const ffmpegManager_1 = require("./services/ffmpegManager");
+const audioFormats_1 = require("./audioFormats");
 class GeminiService {
     // Get FFmpeg path for this service
     async getFFmpegPath() {
@@ -315,14 +316,7 @@ Return as JSON:
                 if (progressCallback) {
                     progressCallback(25, 'Uploading large file to Gemini...');
                 }
-                const fileExt = path.extname(audioFilePath).toLowerCase();
-                let mimeType = 'audio/mp3';
-                if (fileExt === '.wav') {
-                    mimeType = 'audio/wav';
-                }
-                else if (fileExt === '.m4a') {
-                    mimeType = 'audio/mp4';
-                }
+                const mimeType = (0, audioFormats_1.mimeTypeForExtension)(path.extname(audioFilePath));
                 const fileData = fs.readFileSync(audioFilePath);
                 const uploadResult = await this.ai.files.upload({
                     file: new Blob([fileData], { type: mimeType })
@@ -368,14 +362,7 @@ IMPORTANT:
 - Return ONLY the transcription text, no JSON formatting`;
             let result;
             if (fileUri) {
-                const fileExt = path.extname(audioFilePath).toLowerCase();
-                let mimeType = 'audio/mp3';
-                if (fileExt === '.wav') {
-                    mimeType = 'audio/wav';
-                }
-                else if (fileExt === '.m4a') {
-                    mimeType = 'audio/mp4';
-                }
+                const mimeType = (0, audioFormats_1.mimeTypeForExtension)(path.extname(audioFilePath));
                 result = await this.ai.models.generateContent({
                     model: this.flashModel,
                     contents: [
@@ -401,14 +388,7 @@ IMPORTANT:
             else {
                 const audioData = fs.readFileSync(audioFilePath);
                 const base64Audio = audioData.toString('base64');
-                const fileExt = path.extname(audioFilePath).toLowerCase();
-                let mimeType = 'audio/mp3';
-                if (fileExt === '.wav') {
-                    mimeType = 'audio/wav';
-                }
-                else if (fileExt === '.m4a') {
-                    mimeType = 'audio/mp4';
-                }
+                const mimeType = (0, audioFormats_1.mimeTypeForExtension)(path.extname(audioFilePath));
                 result = await this.ai.models.generateContent({
                     model: this.flashModel,
                     contents: [
@@ -484,8 +464,7 @@ IMPORTANT:
                 console.log(`Starting transcription for segment ${segmentIndex + 1}/${totalSegments} (attempt ${attempt}/${maxRetries})...`);
                 const audioData = fs.readFileSync(segmentFile);
                 const base64Audio = audioData.toString('base64');
-                const fileExt = path.extname(segmentFile).toLowerCase();
-                const mimeType = fileExt === '.mp3' ? 'audio/mp3' : 'audio/wav';
+                const mimeType = (0, audioFormats_1.mimeTypeForExtension)(path.extname(segmentFile));
                 const result = await this.ai.models.generateContent({
                     model: this.flashModel,
                     contents: [

package/dist/main.js

@@ -34,6 +34,8 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 const electron_1 = require("electron");
+const child_process_1 = require("child_process");
+const util_1 = require("util");
 const path = __importStar(require("path"));
 const fs = __importStar(require("fs"));
 const simpleAudioRecorder_1 = require("./simpleAudioRecorder");
@@ -52,6 +54,7 @@ const releaseNotesService_1 = require("./services/releaseNotesService");
 const outputService_1 = require("./outputService");
 const searchService_1 = require("./searchService");
 const agentService_1 = require("./agentService");
+const audioFormats_1 = require("./audioFormats");
 global.isQuitting = false;
 let mainWindow = null;
 const audioRecorder = new simpleAudioRecorder_1.SimpleAudioRecorder();
@@ -261,8 +264,6 @@ function createWindow() {
     });
 }
 electron_1.app.whenReady().then(() => {
-    // Initialize auto-updater
-    autoUpdaterService_1.autoUpdaterService.checkForUpdates();
     // Create menu with DevTools option
     const template = [
         {
@@ -364,6 +365,9 @@ electron_1.app.whenReady().then(() => {
         autoUpdaterService_1.autoUpdaterService.setMainWindow(mainWindow);
         notificationService_1.notificationService.setMainWindow(mainWindow);
     }
+    // Kick off initial + periodic update checks once the renderer can receive IPC.
+    autoUpdaterService_1.autoUpdaterService.checkForUpdates();
+    autoUpdaterService_1.autoUpdaterService.startPeriodicCheck();
     // Show release notes on first launch after an update.
     checkAndShowReleaseNotes().catch((err) => {
         console.error('Release notes check failed:', err);
@@ -433,6 +437,7 @@ electron_1.app.on('window-all-closed', () => {
 electron_1.app.on('before-quit', () => {
     meetingDetector.stop();
     displayDetector.stop();
+    autoUpdaterService_1.autoUpdaterService.stopPeriodicCheck();
     global.isQuitting = true;
 });
 // Unregister all shortcuts when app quits
@@ -501,46 +506,115 @@ electron_1.ipcMain.handle('cancel-ffmpeg-download', async () => {
     ffmpegManager.cancelDownload();
     return { success: true };
 });
+const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
+// Returns `code: 'ffmpeg-missing'` so the renderer can route users into the
+// existing ffmpeg-download UI (triggered by transcription) rather than
+// duplicating that flow here.
+electron_1.ipcMain.handle('export-recording-m4a', async (_, srcPath) => {
+    try {
+        if (!srcPath || typeof srcPath !== 'string') {
+            return { success: false, error: 'Invalid source path' };
+        }
+        // Containment: the renderer is trusted today, but bound srcPath to the
+        // recordings directory so a future renderer bug can't transcode arbitrary
+        // local files. realpath resolves symlinks before the prefix check.
+        const recordingsDir = path.join(electron_1.app.getPath('userData'), 'recordings');
+        let resolvedSrc;
+        try {
+            resolvedSrc = await fs.promises.realpath(srcPath);
+        }
+        catch {
+            return { success: false, error: 'Source recording not found' };
+        }
+        const resolvedRoot = await fs.promises.realpath(recordingsDir).catch(() => recordingsDir);
+        if (!resolvedSrc.startsWith(resolvedRoot + path.sep)) {
+            return { success: false, error: 'Source path is outside the recordings directory' };
+        }
+        const ffmpegPath = await ffmpegManager.ensureFFmpeg();
+        if (!ffmpegPath) {
+            return { success: false, code: 'ffmpeg-missing', error: 'FFmpeg is required for M4A export.' };
+        }
+        const baseName = path.basename(resolvedSrc, path.extname(resolvedSrc));
+        const dialogOptions = {
+            title: 'Export recording as M4A',
+            defaultPath: `${baseName}.m4a`,
+            filters: [{ name: 'M4A Audio', extensions: ['m4a'] }],
+        };
+        const saveResult = mainWindow
+            ? await electron_1.dialog.showSaveDialog(mainWindow, dialogOptions)
+            : await electron_1.dialog.showSaveDialog(dialogOptions);
+        if (saveResult.canceled || !saveResult.filePath) {
+            return { canceled: true };
+        }
+        const destPath = saveResult.filePath;
+        // Write to a sibling temp file and atomically rename on success so a
+        // failed encode never overwrites the user's picked path with a partial.
+        const tmpPath = `${destPath}.partial`;
+        try {
+            // Force -f ipod (M4A muxer) because the `.partial` extension defeats
+            // ffmpeg's format-by-extension detection otherwise.
+            await execFileAsync(ffmpegPath, [
+                '-y', '-loglevel', 'error',
+                '-i', resolvedSrc,
+                '-vn', '-c:a', 'aac', '-b:a', '128k',
+                '-movflags', '+faststart',
+                '-f', 'ipod',
+                tmpPath,
+            ]);
+            await fs.promises.rename(tmpPath, destPath);
+        }
+        catch (encodeError) {
+            await fs.promises.unlink(tmpPath).catch(() => { });
+            throw encodeError;
+        }
+        return { success: true, path: destPath };
+    }
+    catch (error) {
+        console.error('Error exporting M4A:', error);
+        // execFileAsync rejections carry stderr on the error object — surface it
+        // so renderer-side toasts aren't reduced to "Command failed".
+        const stderr = error?.stderr;
+        const baseMessage = error instanceof Error ? error.message : String(error);
+        const message = stderr ? `${baseMessage.split('\n')[0]} — ${stderr.trim()}` : baseMessage;
+        return { success: false, error: message };
+    }
+});
+// Audio capture runs in the renderer via MediaRecorder; main only tracks state,
+// runs max/reminder timers, updates the menu bar, and writes the final blob to disk.
 electron_1.ipcMain.handle('start-recording', async (_, meetingTitle) => {
     try {
-        const result = await audioRecorder.startRecording(meetingTitle);
-        // Update menu bar icon state
-        if (result.success) {
-            menuBarManager.updateRecordingState(true, meetingTitle);
-            // Set up recording limit timer
-            const maxMinutes = configService.getMaxRecordingMinutes();
-            if (maxMinutes > 0) {
-                recordingMaxTimer = setTimeout(async () => {
-                    clearRecordingTimers();
-                    if (audioRecorder.isRecording()) {
-                        try {
-                            const stopResult = await audioRecorder.stopRecording();
-                            menuBarManager.updateRecordingState(false);
-                            meetingAutoStartedRecording = false;
-                            if (stopResult.success) {
-                                notificationService_1.notificationService.notifyRecordingAutoStopped(maxMinutes);
-                            }
-                            if (mainWindow && !mainWindow.isDestroyed()) {
-                                mainWindow.webContents.send('recording-auto-stopped', stopResult);
-                            }
-                        }
-                        catch (error) {
-                            console.error('Error auto-stopping recording:', error);
-                        }
-                    }
-                }, maxMinutes * 60 * 1000);
-            }
-            // Set up recording reminder interval
-            const reminderMinutes = configService.getRecordingReminderMinutes();
-            if (reminderMinutes > 0) {
-                let elapsed = 0;
-                recordingReminderTimer = setInterval(() => {
-                    elapsed += reminderMinutes;
-                    if (audioRecorder.isRecording()) {
-                        notificationService_1.notificationService.notifyRecordingReminder(elapsed);
-                    }
-                }, reminderMinutes * 60 * 1000);
-            }
+        const result = audioRecorder.startRecording(meetingTitle);
+        if (!result.success)
+            return result;
+        menuBarManager.updateRecordingState(true, meetingTitle);
+        const maxMinutes = configService.getMaxRecordingMinutes();
+        if (maxMinutes > 0) {
+            recordingMaxTimer = setTimeout(() => {
+                clearRecordingTimers();
+                if (!audioRecorder.isRecording())
+                    return;
+                notificationService_1.notificationService.notifyRecordingAutoStopped(maxMinutes);
+                if (mainWindow && !mainWindow.isDestroyed()) {
+                    // Renderer owns MediaRecorder — it will stop, save, and re-enter stop-recording via IPC.
+                    mainWindow.webContents.send('recording-auto-stopped', { reason: 'maxDuration', maxMinutes });
+                }
+                // Always reset main-side state so an unresponsive or hung renderer can't leave the
+                // isRecording() flag stuck and block future recordings. stopRecording() is idempotent,
+                // so the renderer's own stop-recording IPC (if it runs) is a safe no-op here.
+                audioRecorder.stopRecording();
+                menuBarManager.updateRecordingState(false);
+                meetingAutoStartedRecording = false;
+            }, maxMinutes * 60 * 1000);
+        }
+        const reminderMinutes = configService.getRecordingReminderMinutes();
+        if (reminderMinutes > 0) {
+            let elapsed = 0;
+            recordingReminderTimer = setInterval(() => {
+                elapsed += reminderMinutes;
+                if (audioRecorder.isRecording()) {
+                    notificationService_1.notificationService.notifyRecordingReminder(elapsed);
+                }
+            }, reminderMinutes * 60 * 1000);
         }
         return result;
     }
@@ -553,17 +627,31 @@ electron_1.ipcMain.handle('start-recording', async (_, meetingTitle) => {
 electron_1.ipcMain.handle('stop-recording', async () => {
     try {
         clearRecordingTimers();
-        const result = await audioRecorder.stopRecording();
-        // Update menu bar icon state
+        const result = audioRecorder.stopRecording();
         menuBarManager.updateRecordingState(false);
         meetingAutoStartedRecording = false;
+        return result;
+    }
+    catch (error) {
+        console.error('Error stopping recording:', error);
+        return { success: false, error: error instanceof Error ? error.message : String(error) };
+    }
+});
+// Receives the encoded audio blob from the renderer after MediaRecorder finalizes.
+// The "stopped" notification only fires once the file is actually on disk — otherwise
+// a failed write would still show a success toast.
+electron_1.ipcMain.handle('save-recording', async (_, payload) => {
+    try {
+        const buf = Buffer.from(payload.data);
+        const extension = (0, audioFormats_1.extensionForMimeType)(payload.mimeType);
+        const result = await audioRecorder.saveRecording(payload.title, buf, extension, payload.durationMs);
         if (result.success) {
             notificationService_1.notificationService.notifyRecordingStopped();
         }
         return result;
     }
     catch (error) {
-        console.error('Error stopping recording:', error);
+        console.error('Error saving recording:', error);
         return { success: false, error: error instanceof Error ? error.message : String(error) };
     }
 });
@@ -623,6 +711,19 @@ electron_1.ipcMain.handle('get-all-releases', async () => {
     console.log(`Release list IPC: fetched ${results.length} releases`);
     return results;
 });
+electron_1.ipcMain.handle('update:get-state', async () => {
+    return autoUpdaterService_1.autoUpdaterService.getUpdateState();
+});
+electron_1.ipcMain.handle('update:download', async () => {
+    autoUpdaterService_1.autoUpdaterService.downloadUpdate();
+});
+electron_1.ipcMain.handle('update:install', async () => {
+    autoUpdaterService_1.autoUpdaterService.quitAndInstall();
+});
+// Dev-only: drive the badge state machine manually from DevTools.
+electron_1.ipcMain.handle('update:simulate', async (_, event, data) => {
+    autoUpdaterService_1.autoUpdaterService.simulateUpdateEvent(event, data);
+});
 electron_1.ipcMain.handle('check-config', async () => {
     return {
         hasConfig: configService.hasRequiredConfig(),
@@ -790,7 +891,7 @@ electron_1.ipcMain.handle('get-metadata', async (_, filePath) => {
             return { success: true, data: null };
         // New format: read from transcription folder
         if (metadata.transcriptionPath) {
-            const transcription = (0, outputService_1.readTranscription)(metadata.transcriptionPath);
+            const transcription = await (0, outputService_1.readTranscription)(metadata.transcriptionPath);
             if (transcription) {
                 return {
                     success: true,
@@ -834,6 +935,20 @@ electron_1.ipcMain.handle('open-recordings-folder', async () => {
     // Open the folder in the system file explorer
     electron_1.shell.openPath(recordingsPath);
 });
+// Reveal a specific recording in Finder/Explorer. This gives the user a
+// one-click path to native OS share tools (right-click -> Share -> AirDrop,
+// Messages, Mail, KakaoTalk, etc.) without us having to integrate each target.
+electron_1.ipcMain.handle('show-in-finder', (_, filePath) => {
+    if (!filePath)
+        return { success: false, error: 'No file path provided' };
+    try {
+        electron_1.shell.showItemInFolder(filePath);
+        return { success: true };
+    }
+    catch (error) {
+        return { success: false, error: error instanceof Error ? error.message : String(error) };
+    }
+});
 // Search past transcriptions
 electron_1.ipcMain.handle('search-transcriptions', async (_, opts) => {
     try {
@@ -847,7 +962,7 @@ electron_1.ipcMain.handle('search-transcriptions', async (_, opts) => {
         const fields = filtered.length > 0 ? filtered : searchService_1.ALL_FIELDS;
         const limit = Number.isFinite(opts.limit) && opts.limit >= 0 ? opts.limit : 20;
         const dataPath = electron_1.app.getPath('userData');
-        const raw = (0, searchService_1.searchTranscriptions)(dataPath, { query, fields, limit });
+        const raw = await (0, searchService_1.searchTranscriptions)(dataPath, { query, fields, limit });
         const hits = raw.map((h) => ({
             folderName: h.entry.folderName,
             folderPath: h.entry.folderPath,
@@ -891,7 +1006,7 @@ electron_1.ipcMain.handle('get-recordings', async () => {
             // Filter out segment files
             if (file.includes('_segment_'))
                 return false;
-            return file.endsWith('.mp3') || file.endsWith('.wav') || file.endsWith('.m4a');
+            return (0, audioFormats_1.isSupportedAudioExtension)(path.extname(file));
         })
             .map((file) => {
             const filePath = path.join(recordingsDir, file);

package/dist/outputService.js

@@ -239,25 +239,39 @@ function saveTranscription(opts) {
  * List transcription folders sorted by most-recent-first.
  * Performs a lightweight line scan of each summary.md to extract only title and transcribedAt.
  */
-function listTranscriptions(dataPath, limit) {
+async function listTranscriptions(dataPath, limit) {
     const dir = getTranscriptionsDir(dataPath);
-    if (!fs.existsSync(dir))
-        return [];
+    let dirents;
+    try {
+        dirents = await fs.promises.readdir(dir, { withFileTypes: true });
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return [];
+        throw err;
+    }
     const entries = [];
-    for (const name of fs.readdirSync(dir)) {
-        const folderPath = path.join(dir, name);
-        if (!fs.statSync(folderPath).isDirectory())
+    for (const dirent of dirents) {
+        if (!dirent.isDirectory())
             continue;
+        const name = dirent.name;
+        const folderPath = path.join(dir, name);
         const summaryPath = path.join(folderPath, 'summary.md');
-        if (!fs.existsSync(summaryPath))
-            continue;
         let title = name;
         let transcribedAt = '';
         // Lightweight line scan -- read only frontmatter, not the full file
-        const fd = fs.openSync(summaryPath, 'r');
+        let fileHandle;
+        try {
+            fileHandle = await fs.promises.open(summaryPath, 'r');
+        }
+        catch (err) {
+            if (err.code === 'ENOENT')
+                continue;
+            throw err;
+        }
         try {
             const buf = Buffer.alloc(2048);
-            const bytesRead = fs.readSync(fd, buf, 0, 2048, 0);
+            const { bytesRead } = await fileHandle.read(buf, 0, 2048, 0);
             const head = buf.toString('utf-8', 0, bytesRead);
             for (const line of head.split('\n')) {
                 const titleMatch = line.match(/^title:\s*(.+)$/);
@@ -272,7 +286,7 @@ function listTranscriptions(dataPath, limit) {
             }
         }
         finally {
-            fs.closeSync(fd);
+            await fileHandle.close();
         }
         // Fall back to folder name timestamp suffix (e.g. _20260219_143000)
         if (!transcribedAt) {
@@ -292,12 +306,10 @@ function listTranscriptions(dataPath, limit) {
  * Read transcription data from a transcription folder.
  * Returns raw data from frontmatter (machine-readable), not the markdown body.
  */
-function readTranscription(folderPath) {
+async function readTranscription(folderPath) {
     try {
         const summaryPath = path.join(folderPath, 'summary.md');
-        if (!fs.existsSync(summaryPath))
-            return null;
-        const summaryContent = fs.readFileSync(summaryPath, 'utf-8');
+        const summaryContent = await fs.promises.readFile(summaryPath, 'utf-8');
         const { meta } = parseFrontmatter(summaryContent);
         // Parse customFields from frontmatter (stored as JSON string)
         let customFields;

package/dist/searchService.js

@@ -122,14 +122,14 @@ function resolveFields(opts) {
     return opts.includeTranscript ? [...exports.ALL_FIELDS] : [...exports.DEFAULT_FIELDS];
 }
 /** Run a search against the local transcriptions archive. */
-function searchTranscriptions(dataPath, opts) {
-    const entries = (0, outputService_1.listTranscriptions)(dataPath, 0);
+async function searchTranscriptions(dataPath, opts) {
+    const entries = await (0, outputService_1.listTranscriptions)(dataPath, 0);
     const fields = opts.fields ?? exports.DEFAULT_FIELDS;
     const needle = opts.query.toLowerCase();
     const scope = new Set(fields);
     const hits = [];
     for (const entry of entries) {
-        const data = (0, outputService_1.readTranscription)(entry.folderPath);
+        const data = await (0, outputService_1.readTranscription)(entry.folderPath);
         if (!data)
             continue;
         const hit = scoreRecordPrepared(entry, data, needle, scope);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "listener-ai",
-  "version": "2.0.0",
+  "version": "2.1.1",
   "description": "A lightweight desktop application for recording and transcribing meetings with AI-powered notes.",
   "main": "dist/main.js",
   "bin": {
@@ -48,7 +48,7 @@
     "@types/fs-extra": "^11.0.4",
     "@types/node": "^24.0.12",
     "dotenv": "^17.2.0",
-    "electron": "^37.3.1",
+    "electron": "^39.8.5",
     "electron-builder": "^26.8.1",
     "semver": "^7.7.2",
     "typescript": "^5.8.3"