meeting-noter 0.3.0__py3-none-any.whl

meeting_noter/audio/system_audio.py

@@ -0,0 +1,363 @@
+"""System audio capture using ScreenCaptureKit (macOS 12.3+).
+
+This captures system audio by requesting Screen Recording permission,
+similar to how Notion and other apps work. No special audio devices needed.
+"""
+
+from __future__ import annotations
+
+import ctypes
+import numpy as np
+from collections import deque
+from queue import Queue, Empty
+from threading import Event, Thread
+from typing import Optional
+import sys
+
+
+SAMPLE_RATE = 48000
+CHANNELS = 2
+
+
+class ScreenCaptureAudio:
+    """Captures system audio using ScreenCaptureKit.
+
+    Requires Screen Recording permission (System Settings > Privacy > Screen Recording).
+    """
+
+    def __init__(self, sample_rate: int = SAMPLE_RATE, channels: int = CHANNELS):
+        self.sample_rate = sample_rate
+        self.channels = channels
+        self.audio_queue: Queue[np.ndarray] = Queue()
+        self._is_running = False
+        self._stream = None
+        self._delegate = None
+        self._dispatch_queue = None
+
+    def _check_availability(self) -> bool:
+        """Check if ScreenCaptureKit is available."""
+        if sys.platform != "darwin":
+            return False
+        try:
+            import ScreenCaptureKit
+            return True
+        except ImportError:
+            return False
+
+    def start(self) -> bool:
+        """Start capturing system audio.
+
+        Returns True if successful, False if not available or permission denied.
+        """
+        if not self._check_availability():
+            return False
+
+        try:
+            import ScreenCaptureKit as SCK
+            import CoreMedia as CM
+            from Foundation import NSObject
+            import threading
+
+            # Try to import dispatch queue creation
+            dispatch_queue_create = None
+            DISPATCH_QUEUE_SERIAL = None
+            try:
+                from libdispatch import dispatch_queue_create, DISPATCH_QUEUE_SERIAL
+            except ImportError:
+                try:
+                    from dispatch import dispatch_queue_create, DISPATCH_QUEUE_SERIAL
+                except ImportError:
+                    pass  # Will use None for queue, ScreenCaptureKit uses default
+
+            audio_queue = self.audio_queue
+            parent = self
+
+            # Create delegate class for receiving audio data
+            class StreamOutput(NSObject):
+                def stream_didOutputSampleBuffer_ofType_(self, stream, sampleBuffer, outputType):
+                    # Only process audio (type 1), ignore video (type 0)
+                    if outputType != 1:
+                        return
+
+                    try:
+                        blockBuffer = CM.CMSampleBufferGetDataBuffer(sampleBuffer)
+                        if blockBuffer is None:
+                            return
+
+                        length = CM.CMBlockBufferGetDataLength(blockBuffer)
+                        if length == 0:
+                            return
+
+                        # Create contiguous buffer copy
+                        result = CM.CMBlockBufferCreateContiguous(
+                            None, blockBuffer, None, None, 0, length, 0, None
+                        )
+
+                        if result[0] == 0:  # noErr
+                            contigBuffer = result[1]
+                            dataResult = CM.CMBlockBufferGetDataPointer(
+                                contigBuffer, 0, None, None, None
+                            )
+
+                            if dataResult[0] == 0:
+                                dataPtr = dataResult[3]
+
+                                # First element of tuple is the memory address
+                                if isinstance(dataPtr, tuple) and len(dataPtr) > 0:
+                                    ptr_addr = dataPtr[0]
+                                    num_floats = length // 4
+
+                                    # Cast pointer to float array
+                                    float_ptr = ctypes.cast(
+                                        ptr_addr, ctypes.POINTER(ctypes.c_float)
+                                    )
+                                    audio = np.ctypeslib.as_array(
+                                        float_ptr, shape=(num_floats,)
+                                    ).copy()
+
+                                    if len(audio) > 0:
+                                        audio_queue.put(audio)
+
+                    except Exception:
+                        pass
+
+                def stream_didStopWithError_(self, stream, error):
+                    parent._is_running = False
+
+            self._delegate = StreamOutput.alloc().init()
+
+            # Create dispatch queue if available, otherwise use None (default queue)
+            if dispatch_queue_create is not None:
+                self._dispatch_queue = dispatch_queue_create(
+                    b"com.meetingnoter.screencapture",
+                    DISPATCH_QUEUE_SERIAL
+                )
+            else:
+                self._dispatch_queue = None
+
+            # Get shareable content
+            content_ready = threading.Event()
+            content_result = [None, None]
+
+            def on_content(content, error):
+                content_result[0] = content
+                content_result[1] = error
+                content_ready.set()
+
+            SCK.SCShareableContent.getShareableContentWithCompletionHandler_(on_content)
+
+            if not content_ready.wait(timeout=5.0):
+                return False
+
+            content, error = content_result
+            if error or not content:
+                return False
+
+            if not content.displays() or len(content.displays()) == 0:
+                return False
+
+            # Create filter for main display
+            display = content.displays()[0]
+            contentFilter = SCK.SCContentFilter.alloc().initWithDisplay_excludingWindows_(
+                display, []
+            )
+
+            # Configure stream
+            config = SCK.SCStreamConfiguration.alloc().init()
+
+            # Audio settings
+            config.setCapturesAudio_(True)
+            config.setExcludesCurrentProcessAudio_(False)
+            config.setSampleRate_(self.sample_rate)
+            config.setChannelCount_(self.channels)
+
+            # Minimal video settings (required for audio to work)
+            # Note: 1x1 causes errors, need at least ~100x100
+            config.setWidth_(100)
+            config.setHeight_(100)
+            config.setMinimumFrameInterval_(CM.CMTimeMake(1, 2))  # 0.5 fps
+
+            # Create stream
+            self._stream = SCK.SCStream.alloc().initWithFilter_configuration_delegate_(
+                contentFilter, config, self._delegate
+            )
+
+            if self._stream is None:
+                return False
+
+            # Add both video and audio outputs (both required for audio to work)
+            self._stream.addStreamOutput_type_sampleHandlerQueue_error_(
+                self._delegate, 0, self._dispatch_queue, None  # Video
+            )
+            self._stream.addStreamOutput_type_sampleHandlerQueue_error_(
+                self._delegate, 1, self._dispatch_queue, None  # Audio
+            )
+
+            # Start capture
+            start_ready = threading.Event()
+            start_error = [None]
+
+            def on_start(error):
+                start_error[0] = error
+                start_ready.set()
+
+            self._stream.startCaptureWithCompletionHandler_(on_start)
+
+            if not start_ready.wait(timeout=5.0):
+                return False
+
+            if start_error[0]:
+                error = start_error[0]
+                error_code = error.code()
+                if error_code == 1003:
+                    print("Screen Recording permission required.")
+                    print("  Go to: System Settings > Privacy & Security > Screen Recording")
+                    print("  Enable permission for Terminal/your app, then restart.")
+                return False
+
+            self._is_running = True
+            return True
+
+        except Exception as e:
+            print(f"ScreenCaptureKit error: {e}")
+            return False
+
+    def stop(self):
+        """Stop capturing."""
+        self._is_running = False
+
+        if self._stream:
+            try:
+                stop_done = Event()
+                self._stream.stopCaptureWithCompletionHandler_(lambda e: stop_done.set())
+                stop_done.wait(timeout=2.0)
+            except Exception:
+                pass
+            self._stream = None
+
+    def get_audio(self, timeout: float = 1.0) -> Optional[np.ndarray]:
+        """Get captured audio data."""
+        try:
+            return self.audio_queue.get(timeout=timeout)
+        except Empty:
+            return None
+
+    @property
+    def is_running(self) -> bool:
+        return self._is_running
+
+
+class CombinedAudioCapture:
+    """Captures both microphone and system audio (meeting participants).
+
+    Uses default microphone for user's voice and ScreenCaptureKit for system audio.
+    """
+
+    def __init__(self, sample_rate: int = SAMPLE_RATE):
+        self._sample_rate = sample_rate
+        self._channels = CHANNELS
+        self.audio_queue: Queue[np.ndarray] = Queue()
+        self.stop_event = Event()
+
+        self._mic_capture = None
+        self._system_capture = None
+        self._has_system_audio = False
+        self._output_thread = None
+
+    def start(self):
+        """Start capturing from microphone and system audio."""
+        from meeting_noter.audio.capture import AudioCapture
+
+        self.stop_event.clear()
+
+        # Start microphone capture
+        self._mic_capture = AudioCapture(sample_rate=self._sample_rate)
+        self._mic_capture.start()
+        self._channels = self._mic_capture.channels
+
+        # Try ScreenCaptureKit for system audio
+        self._system_capture = ScreenCaptureAudio(
+            sample_rate=self._sample_rate,
+            channels=self._channels
+        )
+        self._has_system_audio = self._system_capture.start()
+
+        if self._has_system_audio:
+            print("Capturing: microphone + system audio (ScreenCaptureKit)")
+        else:
+            print("Capturing: microphone only")
+            print("  Grant Screen Recording permission to capture other participants")
+
+        # Start output thread
+        self._output_thread = Thread(target=self._process_audio, daemon=True)
+        self._output_thread.start()
+
+    def _process_audio(self):
+        """Process and output audio from both sources."""
+        # Ring buffers for accumulating audio
+        mic_buffer = deque(maxlen=self._sample_rate)  # 1 second buffer
+        sys_buffer = deque(maxlen=self._sample_rate)
+
+        # Target chunk size (20ms at sample_rate)
+        chunk_size = int(self._sample_rate * 0.02)
+
+        while not self.stop_event.is_set():
+            # Collect mic audio
+            if self._mic_capture:
+                mic_audio = self._mic_capture.get_audio(timeout=0.01)
+                if mic_audio is not None:
+                    mic_buffer.extend(mic_audio.flatten())
+
+            # Collect system audio
+            if self._system_capture and self._system_capture.is_running:
+                sys_audio = self._system_capture.get_audio(timeout=0.01)
+                if sys_audio is not None:
+                    sys_buffer.extend(sys_audio.flatten())
+
+            # Output when we have enough mic samples
+            if len(mic_buffer) >= chunk_size:
+                # Get mic chunk
+                mic_chunk = np.array([mic_buffer.popleft() for _ in range(min(chunk_size, len(mic_buffer)))], dtype=np.float32)
+
+                # Get matching system audio if available
+                if self._has_system_audio and len(sys_buffer) >= chunk_size:
+                    sys_chunk = np.array([sys_buffer.popleft() for _ in range(min(chunk_size, len(sys_buffer)))], dtype=np.float32)
+
+                    # Mix: average the two sources
+                    min_len = min(len(mic_chunk), len(sys_chunk))
+                    if min_len > 0:
+                        mixed = np.clip(mic_chunk[:min_len] * 0.7 + sys_chunk[:min_len] * 0.7, -1.0, 1.0)
+                        self.audio_queue.put(mixed)
+                    else:
+                        self.audio_queue.put(mic_chunk)
+                else:
+                    # Just output mic
+                    self.audio_queue.put(mic_chunk)
+
+    def stop(self):
+        """Stop all capture."""
+        self.stop_event.set()
+
+        if self._mic_capture:
+            self._mic_capture.stop()
+        if self._system_capture:
+            self._system_capture.stop()
+
+    def get_audio(self, timeout: float = 1.0) -> Optional[np.ndarray]:
+        """Get mixed audio data."""
+        try:
+            return self.audio_queue.get(timeout=timeout)
+        except Empty:
+            return None
+
+    @property
+    def channels(self) -> int:
+        return self._channels
+
+    @property
+    def sample_rate(self) -> int:
+        return self._sample_rate
+
+    @property
+    def has_system_audio(self) -> bool:
+        return self._has_system_audio

meeting_noter/cli.py

@@ -0,0 +1,308 @@
+"""CLI commands for Meeting Noter."""
+
+from __future__ import annotations
+
+import click
+from pathlib import Path
+from typing import Optional
+
+from meeting_noter import __version__
+from meeting_noter.config import (
+    get_config,
+    require_setup,
+    is_setup_complete,
+    generate_meeting_name,
+)
+
+
+# Default paths
+DEFAULT_PID_FILE = Path.home() / ".meeting-noter.pid"
+
+
+def _launch_gui_background():
+    """Launch the GUI in background and return immediately."""
+    import subprocess
+    import sys
+
+    subprocess.Popen(
+        [sys.executable, "-m", "meeting_noter.gui"],
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+        start_new_session=True,
+    )
+    click.echo("Meeting Noter GUI launched.")
+
+
+@click.group(invoke_without_command=True)
+@click.version_option(version=__version__)
+@click.pass_context
+def cli(ctx):
+    """Meeting Noter - Offline meeting transcription.
+
+    Run 'meeting-noter' to launch the GUI, or use subcommands:
+    - setup: One-time setup (Screen Recording permission)
+    - start <name>: Interactive foreground recording
+    - gui: Launch desktop GUI
+    - menubar: Launch menu bar app
+    """
+    if ctx.invoked_subcommand is None:
+        # No subcommand - launch GUI in background
+        _launch_gui_background()
+
+
+@cli.command()
+def setup():
+    """Set up Meeting Noter and initialize configuration.
+
+    This is a one-time setup that:
+    1. Requests Screen Recording permission (for capturing meeting audio)
+    2. Initializes configuration file
+    3. Creates recording directories
+    """
+    from meeting_noter.install.macos import run_setup
+
+    config = get_config()
+
+    # Run the setup
+    run_setup()
+
+    # Mark setup as complete and ensure directories exist
+    config.setup_complete = True
+    config.recordings_dir.mkdir(parents=True, exist_ok=True)
+    config.transcripts_dir.mkdir(parents=True, exist_ok=True)
+    config.save()
+
+    click.echo(f"Recordings will be saved to: {config.recordings_dir}")
+    click.echo(f"Whisper model: {config.whisper_model}")
+
+
+@cli.command()
+@click.argument("name", required=False)
+@require_setup
+def start(name: Optional[str]):
+    """Start an interactive foreground recording session.
+
+    NAME is the meeting name (optional). If not provided, uses a timestamp
+    like "29_Jan_2026_1430".
+
+    Examples:
+        meeting-noter start                    # Uses timestamp name
+        meeting-noter start "Weekly Standup"   # Uses custom name
+
+    Press Ctrl+C to stop recording. The recording will be automatically
+    transcribed if auto_transcribe is enabled in settings.
+    """
+    from meeting_noter.daemon import run_foreground_capture
+
+    config = get_config()
+    output_dir = config.recordings_dir
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    # Use default timestamp name if not provided
+    meeting_name = name if name else generate_meeting_name()
+
+    run_foreground_capture(
+        output_dir=output_dir,
+        meeting_name=meeting_name,
+        auto_transcribe=config.auto_transcribe,
+        whisper_model=config.whisper_model,
+        transcripts_dir=config.transcripts_dir,
+        silence_timeout_minutes=config.silence_timeout,
+    )
+
+
+@cli.command()
+@click.option(
+    "--output-dir", "-o",
+    type=click.Path(),
+    default=None,
+    help="Directory to save recordings (overrides config)",
+)
+@click.option(
+    "--foreground", "-f",
+    is_flag=True,
+    help="Run in foreground instead of as daemon",
+)
+@click.option(
+    "--name", "-n",
+    default=None,
+    help="Meeting name for the recording",
+)
+@require_setup
+def daemon(output_dir: Optional[str], foreground: bool, name: Optional[str]):
+    """Start the background daemon to capture meeting audio.
+
+    The daemon captures your microphone and system audio (via ScreenCaptureKit)
+    and records to MP3 files. Files are automatically segmented when
+    silence is detected (indicating a meeting has ended).
+    """
+    from meeting_noter.daemon import run_daemon
+
+    config = get_config()
+    output_path = Path(output_dir) if output_dir else config.recordings_dir
+    output_path.mkdir(parents=True, exist_ok=True)
+
+    run_daemon(
+        output_path,
+        foreground=foreground,
+        pid_file=DEFAULT_PID_FILE,
+        meeting_name=name,
+    )
+
+
+@cli.command()
+@require_setup
+def status():
+    """Check if the daemon is running."""
+    from meeting_noter.daemon import check_status
+    check_status(DEFAULT_PID_FILE)
+
+
+@cli.command()
+@require_setup
+def stop():
+    """Stop the running daemon."""
+    from meeting_noter.daemon import stop_daemon
+    stop_daemon(DEFAULT_PID_FILE)
+
+
+@cli.command("list")
+@click.option(
+    "--output-dir", "-o",
+    type=click.Path(exists=True),
+    default=None,
+    help="Directory containing recordings (overrides config)",
+)
+@click.option(
+    "--limit", "-n",
+    type=int,
+    default=10,
+    help="Number of recordings to show",
+)
+@require_setup
+def list_recordings(output_dir: Optional[str], limit: int):
+    """List recent meeting recordings."""
+    from meeting_noter.output.writer import list_recordings as _list_recordings
+
+    config = get_config()
+    path = Path(output_dir) if output_dir else config.recordings_dir
+    _list_recordings(path, limit)
+
+
+@cli.command()
+@click.argument("file", required=False)
+@click.option(
+    "--output-dir", "-o",
+    type=click.Path(exists=True),
+    default=None,
+    help="Directory containing recordings (overrides config)",
+)
+@click.option(
+    "--model", "-m",
+    type=click.Choice(["tiny.en", "base.en", "small.en", "medium.en", "large-v3"]),
+    default=None,
+    help="Whisper model size (overrides config)",
+)
+@click.option(
+    "--live", "-l",
+    is_flag=True,
+    help="Real-time transcription of current recording",
+)
+@require_setup
+def transcribe(file: Optional[str], output_dir: Optional[str], model: Optional[str], live: bool):
+    """Transcribe a meeting recording.
+
+    If no FILE is specified, transcribes the most recent recording.
+    Use --live for real-time transcription of an ongoing meeting.
+    """
+    from meeting_noter.transcription.engine import transcribe_file, transcribe_live
+
+    config = get_config()
+    output_path = Path(output_dir) if output_dir else config.recordings_dir
+    whisper_model = model or config.whisper_model
+
+    if live:
+        transcribe_live(output_path, whisper_model)
+    else:
+        transcribe_file(file, output_path, whisper_model, config.transcripts_dir)
+
+
+@cli.command()
+@click.option(
+    "--foreground", "-f",
+    is_flag=True,
+    help="Run in foreground instead of background",
+)
+@require_setup
+def menubar(foreground: bool):
+    """Launch menu bar app for daemon control.
+
+    Adds a menu bar icon for one-click start/stop of the recording daemon.
+    The icon shows "MN" when idle and "MN [filename]" when recording.
+
+    By default, runs in background. Use -f for foreground (debugging).
+    """
+    import subprocess
+    import sys
+
+    if foreground:
+        from meeting_noter.menubar import run_menubar
+        run_menubar()
+    else:
+        # Spawn as background process
+        subprocess.Popen(
+            [sys.executable, "-m", "meeting_noter.menubar"],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            start_new_session=True,
+        )
+        click.echo("Menu bar app started in background.")
+
+
+@cli.command()
+@click.option(
+    "--foreground", "-f",
+    is_flag=True,
+    help="Run in foreground instead of background",
+)
+@require_setup
+def gui(foreground: bool):
+    """Launch the desktop GUI application.
+
+    Opens a window with tabs for:
+    - Recording: Start/stop recordings with meeting names
+    - Meetings: Browse, play, and manage recordings
+    - Settings: Configure directories, models, and preferences
+
+    By default runs in background. Use -f for foreground.
+    """
+    if foreground:
+        from meeting_noter.gui import run_gui
+        run_gui()
+    else:
+        _launch_gui_background()
+
+
+@cli.command()
+def devices():
+    """List available audio devices."""
+    import sounddevice as sd
+
+    devices = sd.query_devices()
+    click.echo("\nAvailable Audio Devices:\n")
+
+    for i, device in enumerate(devices):
+        device_type = []
+        if device["max_input_channels"] > 0:
+            device_type.append("IN")
+        if device["max_output_channels"] > 0:
+            device_type.append("OUT")
+
+        type_str = "/".join(device_type) if device_type else "N/A"
+        click.echo(f"  [{i}] {device['name']} ({type_str})")
+
+    click.echo()
+
+
+if __name__ == "__main__":
+    cli()