meeting-noter 0.3.4__tar.gz → 0.5.1__tar.gz

{meeting_noter-0.3.4 → meeting_noter-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meeting-noter
-Version: 0.3.4
+Version: 0.5.1
 Summary: Offline meeting transcription for macOS with automatic meeting detection
 Author: Victor
 License: MIT
@@ -60,10 +60,10 @@ Offline meeting transcription tool for macOS. Captures both your voice and meeti
 
 ```bash
 # Install dependencies
-brew install ffmpeg lame pkg-config
+brew install ffmpeg lame pkg-config python@3.12
 
-# Install meeting-noter
-pipx install meeting-noter
+# Install meeting-noter (use Python 3.12 for best compatibility)
+pipx install meeting-noter --python /opt/homebrew/bin/python3.12
 ```
 
 Or with pip:
@@ -208,9 +208,10 @@ Config file: `~/.config/meeting-noter/config.json`
 ## Requirements
 
 - macOS 12.3+ (for ScreenCaptureKit)
-- Python 3.9+
+- 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
 
 ## License
 

{meeting_noter-0.3.4 → meeting_noter-0.5.1}/README.md

@@ -15,10 +15,10 @@ Offline meeting transcription tool for macOS. Captures both your voice and meeti
 
 ```bash
 # Install dependencies
-brew install ffmpeg lame pkg-config
+brew install ffmpeg lame pkg-config python@3.12
 
-# Install meeting-noter
-pipx install meeting-noter
+# Install meeting-noter (use Python 3.12 for best compatibility)
+pipx install meeting-noter --python /opt/homebrew/bin/python3.12
 ```
 
 Or with pip:
@@ -163,9 +163,10 @@ Config file: `~/.config/meeting-noter/config.json`
 ## Requirements
 
 - macOS 12.3+ (for ScreenCaptureKit)
-- Python 3.9+
+- 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
 
 ## License
 

{meeting_noter-0.3.4 → meeting_noter-0.5.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "meeting-noter"
-version = "0.3.4"
+version = "0.5.1"
 description = "Offline meeting transcription for macOS with automatic meeting detection"
 readme = "README.md"
 license = {text = "MIT"}

{meeting_noter-0.3.4 → meeting_noter-0.5.1}/src/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-0.5.1/src/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.4 → meeting_noter-0.5.1}/src/meeting_noter.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meeting-noter
-Version: 0.3.4
+Version: 0.5.1
 Summary: Offline meeting transcription for macOS with automatic meeting detection
 Author: Victor
 License: MIT
@@ -60,10 +60,10 @@ Offline meeting transcription tool for macOS. Captures both your voice and meeti
 
 ```bash
 # Install dependencies
-brew install ffmpeg lame pkg-config
+brew install ffmpeg lame pkg-config python@3.12
 
-# Install meeting-noter
-pipx install meeting-noter
+# Install meeting-noter (use Python 3.12 for best compatibility)
+pipx install meeting-noter --python /opt/homebrew/bin/python3.12
 ```
 
 Or with pip:
@@ -208,9 +208,10 @@ Config file: `~/.config/meeting-noter/config.json`
 ## Requirements
 
 - macOS 12.3+ (for ScreenCaptureKit)
-- Python 3.9+
+- 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
 
 ## License
 

{meeting_noter-0.3.4 → meeting_noter-0.5.1}/src/meeting_noter.egg-info/SOURCES.txt

@@ -7,6 +7,7 @@ src/meeting_noter/config.py
 src/meeting_noter/daemon.py
 src/meeting_noter/meeting_detector.py
 src/meeting_noter/menubar.py
+src/meeting_noter/mic_monitor.py
 src/meeting_noter.egg-info/PKG-INFO
 src/meeting_noter.egg-info/SOURCES.txt
 src/meeting_noter.egg-info/dependency_links.txt