meeting-noter 0.3.5__py3-none-any.whl → 0.6.0__py3-none-any.whl

meeting_noter/audio/encoder.py

@@ -1,37 +1,21 @@
-"""MP3 encoding for audio recordings."""
+"""MP3 encoding for audio recordings using ffmpeg."""
 
 from __future__ import annotations
 
 import re
-import sys
+import subprocess
 import numpy as np
 from pathlib import Path
 from datetime import datetime
 from typing import Optional, Tuple
 
-# Try to import lameenc, provide helpful error if not available
+# Get bundled ffmpeg binary path
 try:
-    import lameenc
-    LAMEENC_AVAILABLE = True
+    import imageio_ffmpeg
+    FFMPEG_PATH = imageio_ffmpeg.get_ffmpeg_exe()
 except ImportError:
-    LAMEENC_AVAILABLE = False
-    lameenc = None
-
-
-def _check_lameenc():
-    """Check if lameenc is available, raise helpful error if not."""
-    if not LAMEENC_AVAILABLE:
-        print("\n" + "=" * 60, file=sys.stderr)
-        print("ERROR: MP3 encoding requires the 'lame' library", file=sys.stderr)
-        print("=" * 60, file=sys.stderr)
-        print("\nTo fix this, run:", file=sys.stderr)
-        print("\n    brew install lame", file=sys.stderr)
-        print("\nThen reinstall meeting-noter:", file=sys.stderr)
-        print("\n    pip install --force-reinstall meeting-noter", file=sys.stderr)
-        print("\n" + "=" * 60 + "\n", file=sys.stderr)
-        raise ImportError(
-            "lameenc not available. Install LAME first: brew install lame"
-        )
+    # Fallback to system ffmpeg
+    FFMPEG_PATH = "ffmpeg"
 
 
 def _sanitize_filename(name: str, max_length: int = 50) -> str:
@@ -62,24 +46,42 @@ def _is_timestamp_name(name: str) -> bool:
 
 
 class MP3Encoder:
-    """Encodes audio data to MP3 format."""
+    """Encodes audio data to MP3 format using ffmpeg."""
 
     def __init__(
         self,
+        output_path: Path,
         sample_rate: int = 16000,
         channels: int = 1,
         bitrate: int = 128,
-        quality: int = 2,
     ):
-        _check_lameenc()
+        self.output_path = output_path
         self.sample_rate = sample_rate
         self.channels = channels
-        self.encoder = lameenc.Encoder()
-        self.encoder.set_bit_rate(bitrate)
-        self.encoder.set_in_sample_rate(sample_rate)
-        self.encoder.set_channels(channels)
-        self.encoder.set_quality(quality)  # 2 = high quality
-        self._buffer = bytearray()
+        self.bitrate = bitrate
+        self._process: Optional[subprocess.Popen] = None
+        self._start_ffmpeg()
+
+    def _start_ffmpeg(self):
+        """Start ffmpeg process for encoding."""
+        cmd = [
+            FFMPEG_PATH,
+            "-y",  # Overwrite output
+            "-f", "s16le",  # Input format: signed 16-bit little-endian PCM
+            "-ar", str(self.sample_rate),  # Sample rate
+            "-ac", str(self.channels),  # Channels
+            "-i", "pipe:0",  # Read from stdin
+            "-codec:a", "libmp3lame",  # MP3 encoder
+            "-b:a", f"{self.bitrate}k",  # Bitrate
+            "-f", "mp3",  # Output format
+            str(self.output_path),
+        ]
+        self._process = subprocess.Popen(
+            cmd,
+            stdin=subprocess.PIPE,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
 
     def encode_chunk(self, audio: np.ndarray) -> bytes:
         """Encode a chunk of audio data.
@@ -88,16 +90,29 @@ class MP3Encoder:
             audio: Float32 audio data, values between -1 and 1
 
         Returns:
-            MP3 encoded bytes
+            Empty bytes (ffmpeg writes directly to file)
         """
+        if self._process is None or self._process.stdin is None:
+            return b""
+
         # Convert float32 to int16
         int_data = (audio * 32767).astype(np.int16)
-        mp3_data = self.encoder.encode(int_data.tobytes())
-        return mp3_data
+        try:
+            self._process.stdin.write(int_data.tobytes())
+        except BrokenPipeError:
+            pass
+        return b""  # ffmpeg writes to file, not returning data
 
     def finalize(self) -> bytes:
-        """Finalize encoding and return remaining data."""
-        return self.encoder.flush()
+        """Finalize encoding."""
+        if self._process is not None and self._process.stdin is not None:
+            try:
+                self._process.stdin.close()
+            except Exception:
+                pass
+            self._process.wait()
+            self._process = None
+        return b""
 
 
 class RecordingSession:
@@ -115,7 +130,6 @@ class RecordingSession:
         self.channels = channels
         self.meeting_name = meeting_name
         self.encoder: Optional[MP3Encoder] = None
-        self.file_handle = None
         self.filepath: Optional[Path] = None
         self.start_time: Optional[datetime] = None
         self.total_samples = 0
@@ -139,22 +153,20 @@ class RecordingSession:
         self.filepath = self.output_dir / filename
 
         self.encoder = MP3Encoder(
+            output_path=self.filepath,
             sample_rate=self.sample_rate,
             channels=self.channels,
         )
-        self.file_handle = open(self.filepath, "wb")
         self.total_samples = 0
 
         return self.filepath
 
     def write(self, audio: np.ndarray):
         """Write audio data to the recording."""
-        if self.encoder is None or self.file_handle is None:
+        if self.encoder is None:
             raise RuntimeError("Recording session not started")
 
-        mp3_data = self.encoder.encode_chunk(audio)
-        if mp3_data:
-            self.file_handle.write(mp3_data)
+        self.encoder.encode_chunk(audio)
         self.total_samples += len(audio)
 
     def stop(self) -> Tuple[Optional[Path], float]:
@@ -166,13 +178,9 @@ class RecordingSession:
         duration = 0.0
         filepath = self.filepath
 
-        if self.encoder and self.file_handle:
-            # Write final data
-            final_data = self.encoder.finalize()
-            if final_data:
-                self.file_handle.write(final_data)
-            self.file_handle.close()
-
+        if self.encoder:
+            # Finalize encoding
+            self.encoder.finalize()
             duration = self.total_samples / self.sample_rate
 
             # Delete if too short (less than 5 seconds)
@@ -181,7 +189,6 @@ class RecordingSession:
                 filepath = None
 
         self.encoder = None
-        self.file_handle = None
         self.filepath = None
         self.start_time = None
         self.total_samples = 0

meeting_noter/menubar.py

@@ -13,7 +13,7 @@ import rumps
 
 from meeting_noter.daemon import read_pid_file, is_process_running, stop_daemon
 from meeting_noter.config import get_config, generate_meeting_name
-from meeting_noter.meeting_detector import MeetingMonitor, MeetingInfo
+from meeting_noter.mic_monitor import MicrophoneMonitor, get_meeting_window_title
 
 
 DEFAULT_PID_FILE = Path.home() / ".meeting-noter.pid"
@@ -42,11 +42,10 @@ class MeetingNoterApp(rumps.App):
         super().__init__("Meeting Noter", title="▷")
         self.pid_file = DEFAULT_PID_FILE
         self.config = get_config()
-        self.meeting_monitor = MeetingMonitor()
+        self.mic_monitor = MicrophoneMonitor()
         self.current_meeting_name: Optional[str] = None
         self.pending_notification = False  # Avoid duplicate notifications
-        self._no_meeting_count = 0  # Counter for auto-stop detection
-        self._initial_check_done = False  # Flag for initial meeting check
+        self._pending_app_name: Optional[str] = None
         self.menu = [
             "Start Recording",
             "Stop Recording",
@@ -138,7 +137,7 @@ class MeetingNoterApp(rumps.App):
         except FileNotFoundError:
             pass
 
-    def _start_recording_with_name(self, meeting_name: str):
+    def _start_recording_with_name(self, meeting_name: str, app_name: Optional[str] = None):
         """Start recording with a specific meeting name."""
         import sys
 
@@ -147,6 +146,7 @@ class MeetingNoterApp(rumps.App):
 
         self.current_meeting_name = meeting_name
         self._save_recording_state(meeting_name)
+        self.mic_monitor.set_recording(True, app_name)
 
         # Start daemon with the meeting name using current Python
         subprocess.Popen(
@@ -167,13 +167,7 @@ class MeetingNoterApp(rumps.App):
             )
             return
 
-        # Check if there's an active meeting to get the name
-        meeting_info = self.meeting_monitor.last_meeting
-        if meeting_info and meeting_info.meeting_name:
-            meeting_name = meeting_info.meeting_name
-        else:
-            meeting_name = generate_meeting_name()
-
+        meeting_name = generate_meeting_name()
         self._start_recording_with_name(meeting_name)
 
         rumps.notification(
@@ -281,58 +275,36 @@ class MeetingNoterApp(rumps.App):
             stderr=subprocess.DEVNULL,
         )
 
-    @rumps.timer(3)
+    @rumps.timer(2)
     def poll_status(self, _):
-        """Periodically update the menu bar title and check for meetings."""
+        """Periodically update the menu bar title and check for mic usage."""
         self._update_title()
 
         is_recording = self._is_running()
 
-        # Check for meeting status changes
-        meeting_started, meeting_ended, meeting_info = self.meeting_monitor.check()
+        # Tell mic monitor our recording state
+        self.mic_monitor.set_recording(is_recording)
 
-        # On first check, treat existing meeting as "started" to show prompt
-        if not self._initial_check_done:
-            self._initial_check_done = True
-            if meeting_info and not is_recording:
-                meeting_started = True
+        # Check for mic usage changes
+        mic_started, mic_stopped, app_name = self.mic_monitor.check()
 
-        # Auto-stop recording when meeting ends
-        if meeting_ended and is_recording:
+        # Auto-stop recording when mic stops being used
+        if mic_stopped and is_recording:
             rumps.notification(
                 title="Meeting Noter",
-                subtitle="Meeting Ended",
+                subtitle="Call Ended",
                 message="Stopping recording...",
             )
-            # Trigger stop recording (will auto-transcribe)
             self._auto_stop_recording()
-            return  # Skip other checks this cycle
-
-        # Also check: if we're recording but no meeting detected for a while
-        # This catches cases where meeting window changes unexpectedly
-        if is_recording and not meeting_info and not self.meeting_monitor.is_in_meeting():
-            # Double-check by waiting one more cycle
-            if hasattr(self, '_no_meeting_count'):
-                self._no_meeting_count += 1
-                if self._no_meeting_count >= 2:  # ~6 seconds of no meeting
-                    rumps.notification(
-                        title="Meeting Noter",
-                        subtitle="Meeting Ended",
-                        message="Stopping recording...",
-                    )
-                    self._auto_stop_recording()
-                    self._no_meeting_count = 0
-            else:
-                self._no_meeting_count = 1
-        else:
-            self._no_meeting_count = 0
+            return
 
-        # Auto-detect new meetings
-        if not is_recording and not self.pending_notification:
-            if meeting_started and meeting_info:
-                self.pending_notification = True
-                self._detected_meeting = meeting_info
-                self._pending_meeting_name = meeting_info.meeting_name or meeting_info.app_name
+        # Prompt to record when mic starts being used
+        if mic_started and not is_recording and not self.pending_notification:
+            self.pending_notification = True
+            self._pending_app_name = app_name or "Unknown App"
+            # Try to get meeting name from window title, fall back to timestamp
+            window_title = get_meeting_window_title()
+            self._pending_meeting_name = window_title or generate_meeting_name()
 
     def _auto_stop_recording(self):
         """Stop recording automatically when meeting ends."""
@@ -384,24 +356,31 @@ class MeetingNoterApp(rumps.App):
     @rumps.timer(1)
     def check_pending_prompt(self, _):
         """Check if we need to show a recording prompt (runs on main thread)."""
-        if self.pending_notification and hasattr(self, '_detected_meeting') and self._detected_meeting:
-            meeting_info = self._detected_meeting
+        if self.pending_notification and hasattr(self, '_pending_meeting_name'):
+            app_name = self._pending_app_name or "App"
             meeting_name = self._pending_meeting_name
 
             # Clear first to prevent re-triggering
-            self._detected_meeting = None
+            self._pending_app_name = None
             self.pending_notification = False
 
+            # Build message with meeting name if available
+            if meeting_name and not meeting_name[0].isdigit():
+                # Has a real meeting name (not timestamp-based)
+                message = f"Meeting: {meeting_name}\n\nDo you want to record?"
+            else:
+                message = "Do you want to record this call?"
+
             # Show alert on main thread
             response = rumps.alert(
-                title=f"Meeting Detected: {meeting_info.app_name}",
-                message=f"Do you want to record '{meeting_name}'?",
+                title=f"Microphone in use: {app_name}",
+                message=message,
                 ok="Record",
                 cancel="Skip",
             )
 
             if response == 1:  # Record clicked
-                self._start_recording_with_name(meeting_name)
+                self._start_recording_with_name(meeting_name, app_name)
                 rumps.notification(
                     title="Meeting Noter",
                     subtitle="Recording Started",

meeting_noter/mic_monitor.py

@@ -0,0 +1,404 @@
+"""Monitor microphone usage to detect when meetings start/end."""
+
+from __future__ import annotations
+
+import ctypes
+from ctypes import c_uint32, c_int32, byref, POINTER, Structure
+import time
+from typing import Optional
+from dataclasses import dataclass
+
+
+@dataclass
+class MicStatus:
+    """Status of microphone usage."""
+    is_in_use: bool
+    app_name: Optional[str] = None
+
+
+# CoreAudio constants
+_kAudioObjectSystemObject = 1
+_kAudioHardwarePropertyDefaultInputDevice = 1682533920  # 'dIn '
+_kAudioDevicePropertyDeviceIsRunningSomewhere = 1735356005  # 'gone'
+_kAudioObjectPropertyScopeGlobal = 1735159650  # 'glob'
+_kAudioObjectPropertyElementMain = 0
+
+
+class _AudioObjectPropertyAddress(Structure):
+    _fields_ = [
+        ('mSelector', c_uint32),
+        ('mScope', c_uint32),
+        ('mElement', c_uint32),
+    ]
+
+
+# Load CoreAudio framework lazily
+_core_audio = None
+_AudioObjectGetPropertyDataSize = None
+_AudioObjectGetPropertyData = None
+
+
+def _init_coreaudio():
+    """Initialize CoreAudio framework."""
+    global _core_audio, _AudioObjectGetPropertyDataSize, _AudioObjectGetPropertyData
+
+    if _core_audio is not None:
+        return True
+
+    try:
+        _core_audio = ctypes.CDLL('/System/Library/Frameworks/CoreAudio.framework/CoreAudio')
+
+        _AudioObjectGetPropertyDataSize = _core_audio.AudioObjectGetPropertyDataSize
+        _AudioObjectGetPropertyDataSize.argtypes = [
+            c_uint32, POINTER(_AudioObjectPropertyAddress), c_uint32, ctypes.c_void_p, POINTER(c_uint32)
+        ]
+        _AudioObjectGetPropertyDataSize.restype = c_int32
+
+        _AudioObjectGetPropertyData = _core_audio.AudioObjectGetPropertyData
+        _AudioObjectGetPropertyData.argtypes = [
+            c_uint32, POINTER(_AudioObjectPropertyAddress), c_uint32, ctypes.c_void_p, POINTER(c_uint32), ctypes.c_void_p
+        ]
+        _AudioObjectGetPropertyData.restype = c_int32
+
+        return True
+    except Exception:
+        return False
+
+
+def is_mic_in_use_by_another_app() -> bool:
+    """Check if the microphone is being used by another application.
+
+    Uses CoreAudio's kAudioDevicePropertyDeviceIsRunningSomewhere property
+    to detect if any app has an active audio input session.
+
+    Returns:
+        True if another app is using the microphone
+    """
+    if not _init_coreaudio():
+        return False
+
+    try:
+        # Get default input device
+        addr = _AudioObjectPropertyAddress(
+            _kAudioHardwarePropertyDefaultInputDevice,
+            _kAudioObjectPropertyScopeGlobal,
+            _kAudioObjectPropertyElementMain
+        )
+
+        size = c_uint32(4)
+        device_id = c_uint32(0)
+
+        err = _AudioObjectGetPropertyData(
+            _kAudioObjectSystemObject, byref(addr), 0, None, byref(size), byref(device_id)
+        )
+
+        if err != 0 or device_id.value == 0:
+            return False
+
+        # Check if device is running somewhere (another app using it)
+        addr_running = _AudioObjectPropertyAddress(
+            _kAudioDevicePropertyDeviceIsRunningSomewhere,
+            _kAudioObjectPropertyScopeGlobal,
+            _kAudioObjectPropertyElementMain
+        )
+
+        is_running = c_uint32(0)
+        size = c_uint32(4)
+
+        err = _AudioObjectGetPropertyData(
+            device_id.value, byref(addr_running), 0, None, byref(size), byref(is_running)
+        )
+
+        return err == 0 and is_running.value != 0
+
+    except Exception:
+        return False
+
+
+def is_meeting_app_active() -> Optional[str]:
+    """Check if a meeting app has an ACTIVE MEETING window.
+
+    Returns the app name only if there's an active call/meeting,
+    not just because the app is open.
+    """
+    try:
+        import Quartz
+
+        # Get all on-screen windows
+        windows = Quartz.CGWindowListCopyWindowInfo(
+            Quartz.kCGWindowListOptionOnScreenOnly,
+            Quartz.kCGNullWindowID
+        )
+
+        for win in windows:
+            owner = win.get(Quartz.kCGWindowOwnerName, "")
+            title = win.get(Quartz.kCGWindowName, "") or ""
+
+            if not owner:
+                continue
+
+            owner_lower = owner.lower()
+            title_lower = title.lower()
+
+            # Zoom: detect meeting windows (not just "Zoom Workplace" or "Zoom")
+            if "zoom.us" in owner_lower:
+                # Skip non-meeting windows
+                if title_lower in ["", "zoom", "zoom workplace", "zoom.us"]:
+                    continue
+                # This is likely a meeting window
+                return "Zoom"
+
+            # Microsoft Teams: detect call windows
+            if "microsoft teams" in owner_lower:
+                # Skip main app windows
+                if title_lower in ["", "microsoft teams"]:
+                    continue
+                # Check for call indicators
+                if any(x in title_lower for x in ["call", "meeting", "chat"]):
+                    return "Teams"
+                return "Teams"
+
+            # Slack: detect huddle/call windows
+            if "slack" in owner_lower:
+                if any(x in title_lower for x in ["huddle", "call"]):
+                    return "Slack"
+
+            # FaceTime
+            if "facetime" in owner_lower:
+                if title and title_lower != "facetime":
+                    return "FaceTime"
+
+            # Webex
+            if "webex" in owner_lower:
+                if title and "meeting" in title_lower:
+                    return "Webex"
+
+            # Discord: detect voice channel
+            if "discord" in owner_lower:
+                # Discord shows voice channel name when in call
+                if title and title_lower != "discord":
+                    return "Discord"
+
+            # Browser-based meetings (Google Meet, etc.)
+            if any(browser in owner_lower for browser in ["chrome", "safari", "firefox", "edge", "brave", "arc"]):
+                # Google Meet: title starts with "Meet -" or contains "meet.google.com"
+                if title_lower.startswith("meet -") or "meet.google.com" in title_lower:
+                    return "Google Meet"
+                # Generic "Meeting" in browser title
+                if " meeting" in title_lower and any(x in title_lower for x in ["zoom", "teams", "webex"]):
+                    return "Browser Meeting"
+
+        return None
+    except Exception:
+        return None
+
+
+def get_meeting_window_title() -> Optional[str]:
+    """Get the window title of the active meeting app.
+
+    Returns the window title (meeting name) if found, None otherwise.
+    """
+    try:
+        import Quartz
+
+        # Known meeting apps
+        meeting_apps = ["zoom.us", "Microsoft Teams", "Slack", "Discord", "FaceTime", "Webex"]
+        browsers = ["chrome", "safari", "firefox", "edge", "brave", "arc"]
+
+        # Get all on-screen windows
+        windows = Quartz.CGWindowListCopyWindowInfo(
+            Quartz.kCGWindowListOptionOnScreenOnly,
+            Quartz.kCGNullWindowID
+        )
+
+        for win in windows:
+            owner = win.get(Quartz.kCGWindowOwnerName, "")
+            title = win.get(Quartz.kCGWindowName, "") or ""
+
+            if not owner:
+                continue
+
+            owner_lower = owner.lower()
+            title_lower = title.lower()
+
+            # Check native meeting apps
+            for app_id in meeting_apps:
+                if app_id.lower() in owner_lower:
+                    if title and _is_meaningful_title(title, owner):
+                        return _clean_meeting_title(title)
+
+            # Check browser-based meetings (Google Meet)
+            if any(browser in owner_lower for browser in browsers):
+                if title_lower.startswith("meet -"):
+                    # Extract meeting code/name from "Meet - xyz-abc-123 🔊"
+                    return _clean_meeting_title(title)
+
+        return None
+    except Exception:
+        return None
+
+
+def _is_meaningful_title(title: str, app_name: str) -> bool:
+    """Check if a window title is meaningful (not just the app name)."""
+    # Skip generic titles
+    generic_titles = [
+        "zoom", "zoom.us", "zoom meeting", "zoom workplace",
+        "microsoft teams", "teams",
+        "slack", "discord", "facetime", "webex",
+        "", " "
+    ]
+
+    title_lower = title.lower().strip()
+
+    # Skip if it's just the app name or a generic title
+    if title_lower in generic_titles:
+        return False
+
+    # Skip Zoom's generic windows
+    if "zoom.us" in app_name.lower():
+        if title_lower in ["zoom", "zoom meeting", "zoom workplace"]:
+            return False
+
+    return True
+
+
+def _clean_meeting_title(title: str) -> str:
+    """Clean up a meeting title for use as a filename."""
+    import re
+
+    # Remove common prefixes/suffixes
+    title = title.strip()
+
+    # Google Meet: "Meet - xyz-abc-123 🔊" -> "Meet_xyz-abc-123"
+    if title.lower().startswith("meet - "):
+        title = "Meet_" + title[7:]
+        # Remove speaker emoji and other indicators
+        title = re.sub(r'[🔊🔇📹]', '', title).strip()
+
+    # Remove "Zoom Meeting - " prefix
+    if title.lower().startswith("zoom meeting - "):
+        title = title[15:]
+
+    # Remove " - Zoom" suffix
+    if title.lower().endswith(" - zoom"):
+        title = title[:-7]
+
+    # Remove " | Microsoft Teams" suffix
+    if " | Microsoft Teams" in title:
+        title = title.split(" | Microsoft Teams")[0]
+
+    # Replace invalid filename characters
+    title = re.sub(r'[<>:"/\\|?*]', '_', title)
+
+    # Replace multiple spaces/underscores with single underscore
+    title = re.sub(r'[\s_]+', '_', title)
+
+    # Limit length
+    if len(title) > 50:
+        title = title[:50]
+
+    return title.strip('_')
+
+
+def get_app_using_mic() -> Optional[str]:
+    """Get the name of the meeting app that might be using the microphone.
+
+    Note: This returns any active meeting app, but doesn't guarantee
+    that specific app is the one using the mic.
+    """
+    return is_meeting_app_active()
+
+
+class MicrophoneMonitor:
+    """Monitor microphone usage to detect meeting start/end.
+
+    Start detection: Another app starts using the microphone
+    Stop detection: The meeting app window is no longer visible
+
+    This approach works because:
+    - Start: CoreAudio tells us when mic is activated (before we start recording)
+    - Stop: We can't rely on mic state (our recording uses it), so we check if meeting app is gone
+    """
+
+    def __init__(self):
+        self._was_mic_in_use = False
+        self._is_recording = False
+        self._recording_app: Optional[str] = None  # Which app triggered recording
+        self._last_check_time = 0
+        self._on_count = 0   # Count consecutive "on" readings
+        self._off_count = 0  # Count consecutive "off" readings
+        self._on_threshold = 2   # Require 2 consecutive "on" readings to trigger start
+        self._off_threshold = 3  # Require 3 consecutive "off" readings to trigger stop
+
+    def set_recording(self, is_recording: bool, app_name: Optional[str] = None):
+        """Tell the monitor whether we're currently recording."""
+        self._is_recording = is_recording
+
+        if is_recording:
+            self._was_mic_in_use = True
+            self._on_count = 0
+            # Only set app_name if provided (don't overwrite on status updates)
+            if app_name:
+                self._recording_app = app_name
+        else:
+            self._recording_app = None
+
+    def check(self) -> tuple[bool, bool, Optional[str]]:
+        """Check for microphone usage changes.
+
+        Returns:
+            Tuple of (mic_started, mic_stopped, app_name)
+            - mic_started: True if another app started using mic (should prompt to record)
+            - mic_stopped: True if meeting app closed (should stop recording)
+            - app_name: Name of meeting app (if detected)
+        """
+        now = time.time()
+
+        # Debounce - check every 2 seconds
+        if now - self._last_check_time < 2.0:
+            return False, False, None
+        self._last_check_time = now
+
+        mic_started = False
+        mic_stopped = False
+        app_name = None
+
+        if self._is_recording:
+            # While recording: check if meeting app is still visible
+            # (Can't rely on mic state since our app is using it)
+            current_app = is_meeting_app_active()
+
+            if current_app is None:
+                # Meeting app window is gone
+                self._off_count += 1
+                if self._off_count >= self._off_threshold:
+                    mic_stopped = True
+                    self._was_mic_in_use = False
+                    self._off_count = 0
+            else:
+                self._off_count = 0
+        else:
+            # Not recording: check if mic is being used by another app
+            mic_in_use = is_mic_in_use_by_another_app()
+
+            if mic_in_use:
+                self._off_count = 0
+                # Get app name for display (optional, doesn't affect start decision)
+                app_name = is_meeting_app_active()
+
+                if not self._was_mic_in_use:
+                    self._on_count += 1
+                    # Require consecutive readings to avoid false positives
+                    if self._on_count >= self._on_threshold:
+                        mic_started = True
+                        self._was_mic_in_use = True
+                        self._on_count = 0
+            else:
+                self._on_count = 0
+                self._was_mic_in_use = False
+
+        return mic_started, mic_stopped, app_name
+
+    def is_mic_active(self) -> bool:
+        """Check if microphone is currently in use by another app."""
+        return is_mic_in_use_by_another_app()

{meeting_noter-0.3.5.dist-info → meeting_noter-0.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meeting-noter
-Version: 0.3.5
+Version: 0.6.0
 Summary: Offline meeting transcription for macOS with automatic meeting detection
 Author: Victor
 License: MIT
@@ -28,14 +28,13 @@ Requires-Dist: numpy>=1.24
 Requires-Dist: faster-whisper>=1.0.0
 Requires-Dist: rumps>=0.4.0
 Requires-Dist: PyQt6>=6.5.0
+Requires-Dist: imageio-ffmpeg>=0.4.9
 Requires-Dist: pyobjc-framework-Cocoa>=9.0; sys_platform == "darwin"
 Requires-Dist: pyobjc-framework-Quartz>=9.0; sys_platform == "darwin"
 Requires-Dist: pyobjc-framework-ScreenCaptureKit>=9.0; sys_platform == "darwin"
 Requires-Dist: pyobjc-framework-AVFoundation>=9.0; sys_platform == "darwin"
 Requires-Dist: pyobjc-framework-CoreMedia>=9.0; sys_platform == "darwin"
 Requires-Dist: pyobjc-framework-libdispatch>=9.0; sys_platform == "darwin"
-Provides-Extra: mp3
-Requires-Dist: lameenc>=1.5.0; extra == "mp3"
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
@@ -59,11 +58,7 @@ Offline meeting transcription tool for macOS. Captures both your voice and meeti
 ## Installation
 
 ```bash
-# Install dependencies
-brew install ffmpeg lame pkg-config python@3.12
-
-# Install meeting-noter (use Python 3.12 for best compatibility)
-pipx install meeting-noter --python /opt/homebrew/bin/python3.12
+pipx install meeting-noter
 ```
 
 Or with pip:
@@ -71,6 +66,8 @@ Or with pip:
 pip install meeting-noter
 ```
 
+No system dependencies required - ffmpeg is bundled automatically.
+
 ## Quick Start
 
 **Menu Bar App** (recommended):
@@ -208,10 +205,7 @@ Config file: `~/.config/meeting-noter/config.json`
 ## Requirements
 
 - macOS 12.3+ (for ScreenCaptureKit)
-- Python 3.9+ (3.12 recommended for best compatibility)
-- FFmpeg (`brew install ffmpeg`) - required for audio processing
-- LAME (`brew install lame`) - required for MP3 encoding
-- pkg-config (`brew install pkg-config`) - required for building dependencies
+- Python 3.9+
 
 ## License
 

{meeting_noter-0.3.5.dist-info → meeting_noter-0.6.0.dist-info}/RECORD

@@ -4,10 +4,11 @@ meeting_noter/cli.py,sha256=w4cBrvg58inkgbApK_z90csBfb4HWBuXveLdD3J1bc0,8540
 meeting_noter/config.py,sha256=41LFBNp5o0IojYS5Hf0FJVIr7GNn7B5O1TJDE8SQkkk,5977
 meeting_noter/daemon.py,sha256=o7U11WmdoKG58SLs70-vzS64kkjMTY5qN0F0bs0eApk,16239
 meeting_noter/meeting_detector.py,sha256=I8zzSdSSmbfd3yyCOyzPL8AS-xSHttFCagrDE35qcho,9412
-meeting_noter/menubar.py,sha256=Wmwaw-_f2Zky6-0DLC5Ql2o6_VBG1-sWacL85dNeGwU,15366
+meeting_noter/menubar.py,sha256=Gn6p8y5jA_HCWf1T3ademxH-vndpONHkf9vUlKs6XEo,14379
+meeting_noter/mic_monitor.py,sha256=Dzt7RZT7-X5US7mT2I247UguR-uLWK0BZDnjiehLD-A,13634
 meeting_noter/audio/__init__.py,sha256=O7PU8CxHSHxMeHbc9Jdwt9kePLQzsPh81GQU7VHCtBY,44
 meeting_noter/audio/capture.py,sha256=fDrT5oXfva8vdFlht9cv60NviKbksw2QeJ8eOtI19uE,6469
-meeting_noter/audio/encoder.py,sha256=C-lGn6S-1KmvfeXMaP032XhifDNMe6sa0RKDZHoZlio,6374
+meeting_noter/audio/encoder.py,sha256=6UgEYLFACSQEIx2nhH1Qq-cBh3qPJziMGkrm39k6Nz8,6401
 meeting_noter/audio/system_audio.py,sha256=jbHGjNCerI19weXap0a90Ik17lVTCT1hCEgRKYke-p8,13016
 meeting_noter/gui/__init__.py,sha256=z5GxxaeXyjqyEa9ox0dQxuL5u_BART0bi7cI6rfntEI,103
 meeting_noter/gui/__main__.py,sha256=A2HWdYod0bTgjQQIi21O7XpmgxLH36e_X0aygEUZLls,146
@@ -31,8 +32,8 @@ meeting_noter/resources/icon_512.png,sha256=o7X3ngYcppcIAAk9AcfPx94MUmrsPRp0qBTp
 meeting_noter/resources/icon_64.png,sha256=TqG7Awx3kK8YdiX1e_z1odZonosZyQI2trlkNZCzUoI,607
 meeting_noter/transcription/__init__.py,sha256=7GY9diP06DzFyoli41wddbrPv5bVDzH35bmnWlIJev4,29
 meeting_noter/transcription/engine.py,sha256=HK2J2QOBNIDm1MXW-gkagXP8C8cqUfK_WylHQD_LqOI,6320
-meeting_noter-0.3.5.dist-info/METADATA,sha256=zHEH6KtcSnH2QF0IK8pOB6J77gAdvCd_hFCt5P7HqXA,7032
-meeting_noter-0.3.5.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-meeting_noter-0.3.5.dist-info/entry_points.txt,sha256=rKNhzjSF5-e3bLRr8LVe22FeiwcacXabCvNpoEXfu4I,56
-meeting_noter-0.3.5.dist-info/top_level.txt,sha256=9Tuq04_0SXM0OXOHVbOHkHkB5tG3fqkrMrfzCMpbLpY,14
-meeting_noter-0.3.5.dist-info/RECORD,,
+meeting_noter-0.6.0.dist-info/METADATA,sha256=Yr8451hXXCNek9wMxOvcXM1ziOFaCTeX70-kiNjUvsc,6654
+meeting_noter-0.6.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+meeting_noter-0.6.0.dist-info/entry_points.txt,sha256=rKNhzjSF5-e3bLRr8LVe22FeiwcacXabCvNpoEXfu4I,56
+meeting_noter-0.6.0.dist-info/top_level.txt,sha256=9Tuq04_0SXM0OXOHVbOHkHkB5tG3fqkrMrfzCMpbLpY,14
+meeting_noter-0.6.0.dist-info/RECORD,,