voice-mode 2.20.1__tar.gz → 2.21.1__tar.gz

{voice_mode-2.20.1 → voice_mode-2.21.1}/CHANGELOG.md

@@ -7,6 +7,22 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.21.1] - 2025-08-13
+
+- Late update to changelog for release 2.21.0
+
+## [2.21.0] - 2025-08-13
+
+### Added
+- **CLI service commands** - New subcommands for managing Whisper and Kokoro services
+  - `voice-mode service whisper start/stop/status/restart/enable/disable/logs`
+  - `voice-mode service kokoro start/stop/status/restart/enable/disable/logs`
+  - `voice-mode service whisper update-service-files` - Update systemd/launchd service files
+  - `voice-mode service kokoro update-service-files` - Update systemd/launchd service files
+  - Unified interface for controlling both STT and TTS services
+  - Direct access to service management without needing MCP client
+  - Consistent behavior across Linux (systemd) and macOS (launchd)
+
 ## [2.20.1] - 2025-08-11
 
 ### Fixed

{voice_mode-2.20.1 → voice_mode-2.21.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: voice-mode
-Version: 2.20.1
+Version: 2.21.1
 Summary: VoiceMode - Voice interaction capabilities for AI assistants (formerly voice-mcp)
 Project-URL: Homepage, https://github.com/mbailey/voicemode
 Project-URL: Repository, https://github.com/mbailey/voicemode

{voice_mode-2.20.1 → voice_mode-2.21.1}/pyproject.toml

@@ -90,7 +90,6 @@ Issues = "https://github.com/mbailey/voicemode/issues"
 [project.scripts]
 voice-mode = "voice_mode.cli:voice_mode"
 voicemode = "voice_mode.cli:voice_mode"
-voice-mode-cli = "voice_mode.cli:cli"
 
 [tool.hatch.build.targets.wheel]
 packages = ["voice_mode"]

{voice_mode-2.20.1 → voice_mode-2.21.1}/voice_mode/__version__.py

@@ -1,3 +1,3 @@
 # This file is automatically updated by 'make release'
 # Do not edit manually
-__version__ = "2.20.1"
+__version__ = "2.21.1"

voice_mode-2.21.1/voice_mode/cli.py

@@ -0,0 +1,593 @@
+"""
+CLI entry points for voice-mode package.
+"""
+import asyncio
+import sys
+import click
+from .server import main as voice_mode_main
+
+
+# Service management CLI - runs MCP server by default, subcommands override
+@click.group(invoke_without_command=True)
+@click.version_option()
+@click.help_option('-h', '--help', help='Show this message and exit')
+@click.pass_context
+def voice_mode_main_cli(ctx):
+    """Voice Mode - MCP server and service management.
+    
+    Without arguments, starts the MCP server.
+    With subcommands, executes service management operations.
+    """
+    if ctx.invoked_subcommand is None:
+        # No subcommand - run MCP server
+        voice_mode_main()
+
+
+def voice_mode() -> None:
+    """Entry point for voicemode command - starts the MCP server or runs subcommands."""
+    voice_mode_main_cli()
+
+
+# Service group commands
+@voice_mode_main_cli.group()
+def kokoro():
+    """Manage Kokoro TTS service."""
+    pass
+
+
+@voice_mode_main_cli.group()
+def whisper():
+    """Manage Whisper STT service."""
+    pass
+
+
+# Import service functions
+from voice_mode.tools.service import (
+    status_service, start_service, stop_service, restart_service,
+    enable_service, disable_service, view_logs, update_service_files
+)
+
+# Import install/uninstall functions
+from voice_mode.tools.services.kokoro.install import kokoro_install
+from voice_mode.tools.services.kokoro.uninstall import kokoro_uninstall
+from voice_mode.tools.services.whisper.install import whisper_install
+from voice_mode.tools.services.whisper.uninstall import whisper_uninstall
+from voice_mode.tools.services.whisper.download_model import download_model
+
+# Import configuration management functions
+from voice_mode.tools.configuration_management import update_config, list_config_keys
+
+# Import diagnostic functions - extract the actual async functions from the tools
+from voice_mode.tools.diagnostics import voice_mode_info
+from voice_mode.tools.devices import check_audio_devices
+from voice_mode.tools.voice_registry import voice_registry
+from voice_mode.tools.dependencies import check_audio_dependencies
+
+
+# Kokoro service commands
+@kokoro.command()
+def status():
+    """Show Kokoro service status."""
+    result = asyncio.run(status_service("kokoro"))
+    click.echo(result)
+
+
+@kokoro.command()
+def start():
+    """Start Kokoro service."""
+    result = asyncio.run(start_service("kokoro"))
+    click.echo(result)
+
+
+@kokoro.command()
+def stop():
+    """Stop Kokoro service."""
+    result = asyncio.run(stop_service("kokoro"))
+    click.echo(result)
+
+
+@kokoro.command()
+def restart():
+    """Restart Kokoro service."""
+    result = asyncio.run(restart_service("kokoro"))
+    click.echo(result)
+
+
+@kokoro.command()
+def enable():
+    """Enable Kokoro service to start at boot/login."""
+    result = asyncio.run(enable_service("kokoro"))
+    click.echo(result)
+
+
+@kokoro.command()
+def disable():
+    """Disable Kokoro service from starting at boot/login."""
+    result = asyncio.run(disable_service("kokoro"))
+    click.echo(result)
+
+
+@kokoro.command()
+@click.option('--lines', '-n', default=50, help='Number of log lines to show')
+def logs(lines):
+    """View Kokoro service logs."""
+    result = asyncio.run(view_logs("kokoro", lines))
+    click.echo(result)
+
+
+@kokoro.command("update-service-files")
+def kokoro_update_service_files():
+    """Update Kokoro service files to latest version."""
+    result = asyncio.run(update_service_files("kokoro"))
+    click.echo(result)
+
+
+@kokoro.command()
+def health():
+    """Check Kokoro health endpoint."""
+    import subprocess
+    try:
+        result = subprocess.run(
+            ["curl", "-s", "http://127.0.0.1:8880/health"],
+            capture_output=True, text=True, timeout=5
+        )
+        if result.returncode == 0:
+            import json
+            try:
+                health_data = json.loads(result.stdout)
+                click.echo("✅ Kokoro is responding")
+                click.echo(f"   Status: {health_data.get('status', 'unknown')}")
+                if 'uptime' in health_data:
+                    click.echo(f"   Uptime: {health_data['uptime']}")
+            except json.JSONDecodeError:
+                click.echo("✅ Kokoro is responding (non-JSON response)")
+        else:
+            click.echo("❌ Kokoro not responding on port 8880")
+    except subprocess.TimeoutExpired:
+        click.echo("❌ Kokoro health check timed out")
+    except Exception as e:
+        click.echo(f"❌ Health check failed: {e}")
+
+
+@kokoro.command()
+@click.option('--install-dir', help='Directory to install kokoro-fastapi')
+@click.option('--port', default=8880, help='Port to configure for the service')
+@click.option('--force', '-f', is_flag=True, help='Force reinstall even if already installed')
+@click.option('--version', default='latest', help='Version to install (default: latest)')
+@click.option('--auto-enable/--no-auto-enable', default=None, help='Enable service at boot/login')
+def install(install_dir, port, force, version, auto_enable):
+    """Install kokoro-fastapi TTS service."""
+    result = asyncio.run(kokoro_install.fn(
+        install_dir=install_dir,
+        port=port,
+        force_reinstall=force,
+        version=version,
+        auto_enable=auto_enable
+    ))
+    
+    if result.get('success'):
+        if result.get('already_installed'):
+            click.echo(f"✅ Kokoro already installed at {result['install_path']}")
+            click.echo(f"   Version: {result.get('version', 'unknown')}")
+        else:
+            click.echo("✅ Kokoro installed successfully!")
+            click.echo(f"   Install path: {result['install_path']}")
+            click.echo(f"   Version: {result.get('version', 'unknown')}")
+            
+        if result.get('enabled'):
+            click.echo("   Auto-start: Enabled")
+        
+        if result.get('migration_message'):
+            click.echo(f"\n{result['migration_message']}")
+    else:
+        click.echo(f"❌ Installation failed: {result.get('error', 'Unknown error')}")
+        if result.get('details'):
+            click.echo(f"   Details: {result['details']}")
+
+
+@kokoro.command()
+@click.option('--remove-models', is_flag=True, help='Also remove downloaded Kokoro models')
+@click.option('--remove-all-data', is_flag=True, help='Remove all Kokoro data including logs and cache')
+@click.confirmation_option(prompt='Are you sure you want to uninstall Kokoro?')
+def uninstall(remove_models, remove_all_data):
+    """Uninstall kokoro-fastapi service and optionally remove data."""
+    result = asyncio.run(kokoro_uninstall.fn(
+        remove_models=remove_models,
+        remove_all_data=remove_all_data
+    ))
+    
+    if result.get('success'):
+        click.echo("✅ Kokoro uninstalled successfully!")
+        
+        if result.get('service_stopped'):
+            click.echo("   Service stopped")
+        if result.get('service_disabled'):
+            click.echo("   Service disabled")
+        if result.get('install_removed'):
+            click.echo(f"   Installation removed: {result['install_path']}")
+        if result.get('models_removed'):
+            click.echo("   Models removed")
+        if result.get('data_removed'):
+            click.echo("   All data removed")
+            
+        if result.get('warnings'):
+            click.echo("\n⚠️  Warnings:")
+            for warning in result['warnings']:
+                click.echo(f"   - {warning}")
+    else:
+        click.echo(f"❌ Uninstall failed: {result.get('error', 'Unknown error')}")
+        if result.get('details'):
+            click.echo(f"   Details: {result['details']}")
+
+
+# Whisper service commands  
+@whisper.command()
+def status():
+    """Show Whisper service status."""
+    result = asyncio.run(status_service("whisper"))
+    click.echo(result)
+
+
+@whisper.command()
+def start():
+    """Start Whisper service."""
+    result = asyncio.run(start_service("whisper"))
+    click.echo(result)
+
+
+@whisper.command()
+def stop():
+    """Stop Whisper service."""
+    result = asyncio.run(stop_service("whisper"))
+    click.echo(result)
+
+
+@whisper.command()
+def restart():
+    """Restart Whisper service."""
+    result = asyncio.run(restart_service("whisper"))
+    click.echo(result)
+
+
+@whisper.command()
+def enable():
+    """Enable Whisper service to start at boot/login."""
+    result = asyncio.run(enable_service("whisper"))
+    click.echo(result)
+
+
+@whisper.command()
+def disable():
+    """Disable Whisper service from starting at boot/login."""
+    result = asyncio.run(disable_service("whisper"))
+    click.echo(result)
+
+
+@whisper.command()
+@click.option('--lines', '-n', default=50, help='Number of log lines to show')
+def logs(lines):
+    """View Whisper service logs."""
+    result = asyncio.run(view_logs("whisper", lines))
+    click.echo(result)
+
+
+@whisper.command("update-service-files")
+def whisper_update_service_files():
+    """Update Whisper service files to latest version."""
+    result = asyncio.run(update_service_files("whisper"))
+    click.echo(result)
+
+
+@whisper.command()
+def health():
+    """Check Whisper health endpoint."""
+    import subprocess
+    try:
+        result = subprocess.run(
+            ["curl", "-s", "http://127.0.0.1:8090/health"],
+            capture_output=True, text=True, timeout=5
+        )
+        if result.returncode == 0:
+            import json
+            try:
+                health_data = json.loads(result.stdout)
+                click.echo("✅ Whisper is responding")
+                click.echo(f"   Status: {health_data.get('status', 'unknown')}")
+                if 'uptime' in health_data:
+                    click.echo(f"   Uptime: {health_data['uptime']}")
+            except json.JSONDecodeError:
+                click.echo("✅ Whisper is responding (non-JSON response)")
+        else:
+            click.echo("❌ Whisper not responding on port 8090")
+    except subprocess.TimeoutExpired:
+        click.echo("❌ Whisper health check timed out")
+    except Exception as e:
+        click.echo(f"❌ Health check failed: {e}")
+
+
+@whisper.command()
+@click.option('--install-dir', help='Directory to install whisper.cpp')
+@click.option('--model', default='large-v2', help='Whisper model to download (default: large-v2)')
+@click.option('--use-gpu/--no-gpu', default=None, help='Enable GPU support if available')
+@click.option('--force', '-f', is_flag=True, help='Force reinstall even if already installed')
+@click.option('--version', default='latest', help='Version to install (default: latest)')
+@click.option('--auto-enable/--no-auto-enable', default=None, help='Enable service at boot/login')
+def install(install_dir, model, use_gpu, force, version, auto_enable):
+    """Install whisper.cpp STT service with automatic system detection."""
+    result = asyncio.run(whisper_install.fn(
+        install_dir=install_dir,
+        model=model,
+        use_gpu=use_gpu,
+        force_reinstall=force,
+        version=version,
+        auto_enable=auto_enable
+    ))
+    
+    if result.get('success'):
+        if result.get('already_installed'):
+            click.echo(f"✅ Whisper already installed at {result['install_path']}")
+            click.echo(f"   Version: {result.get('version', 'unknown')}")
+        else:
+            click.echo("✅ Whisper installed successfully!")
+            click.echo(f"   Install path: {result['install_path']}")
+            click.echo(f"   Version: {result.get('version', 'unknown')}")
+            
+        if result.get('gpu_enabled'):
+            click.echo("   GPU support: Enabled")
+        if result.get('model_downloaded'):
+            click.echo(f"   Model: {result.get('model', 'unknown')}")
+        if result.get('enabled'):
+            click.echo("   Auto-start: Enabled")
+        
+        if result.get('migration_message'):
+            click.echo(f"\n{result['migration_message']}")
+            
+        if result.get('next_steps'):
+            click.echo("\nNext steps:")
+            for step in result['next_steps']:
+                click.echo(f"   - {step}")
+    else:
+        click.echo(f"❌ Installation failed: {result.get('error', 'Unknown error')}")
+        if result.get('details'):
+            click.echo(f"   Details: {result['details']}")
+
+
+@whisper.command()
+@click.option('--remove-models', is_flag=True, help='Also remove downloaded Whisper models')
+@click.option('--remove-all-data', is_flag=True, help='Remove all Whisper data including logs and transcriptions')
+@click.confirmation_option(prompt='Are you sure you want to uninstall Whisper?')
+def uninstall(remove_models, remove_all_data):
+    """Uninstall whisper.cpp and optionally remove models and data."""
+    result = asyncio.run(whisper_uninstall.fn(
+        remove_models=remove_models,
+        remove_all_data=remove_all_data
+    ))
+    
+    if result.get('success'):
+        click.echo("✅ Whisper uninstalled successfully!")
+        
+        if result.get('service_stopped'):
+            click.echo("   Service stopped")
+        if result.get('service_disabled'):
+            click.echo("   Service disabled")
+        if result.get('install_removed'):
+            click.echo(f"   Installation removed: {result['install_path']}")
+        if result.get('models_removed'):
+            click.echo("   Models removed")
+        if result.get('data_removed'):
+            click.echo("   All data removed")
+            
+        if result.get('warnings'):
+            click.echo("\n⚠️  Warnings:")
+            for warning in result['warnings']:
+                click.echo(f"   - {warning}")
+    else:
+        click.echo(f"❌ Uninstall failed: {result.get('error', 'Unknown error')}")
+        if result.get('details'):
+            click.echo(f"   Details: {result['details']}")
+
+
+@whisper.command("download-model")
+@click.argument('model', default='large-v2')
+@click.option('--force', '-f', is_flag=True, help='Re-download even if model exists')
+@click.option('--skip-core-ml', is_flag=True, help='Skip Core ML conversion on Apple Silicon')
+def download_model_cmd(model, force, skip_core_ml):
+    """Download Whisper model(s) with optional Core ML conversion.
+    
+    MODEL can be a model name (e.g., 'large-v2'), 'all' to download all models,
+    or omitted to use the default (large-v2).
+    
+    Available models: tiny, tiny.en, base, base.en, small, small.en,
+    medium, medium.en, large-v1, large-v2, large-v3, large-v3-turbo
+    """
+    import json
+    result = asyncio.run(download_model.fn(
+        model=model,
+        force_download=force,
+        skip_core_ml=skip_core_ml
+    ))
+    
+    try:
+        # Parse JSON response
+        data = json.loads(result)
+        if data.get('success'):
+            click.echo("✅ Model download completed!")
+            
+            if 'results' in data:
+                for model_result in data['results']:
+                    click.echo(f"\n📦 {model_result['model']}:")
+                    if model_result.get('already_exists') and not force:
+                        click.echo("   Already downloaded")
+                    else:
+                        click.echo("   Downloaded successfully")
+                    
+                    if model_result.get('core_ml_converted'):
+                        click.echo("   Core ML: Converted")
+                    elif model_result.get('core_ml_exists'):
+                        click.echo("   Core ML: Already exists")
+            
+            if 'models_dir' in data:
+                click.echo(f"\nModels location: {data['models_dir']}")
+        else:
+            click.echo(f"❌ Download failed: {data.get('error', 'Unknown error')}")
+            if 'available_models' in data:
+                click.echo("\nAvailable models:")
+                for m in data['available_models']:
+                    click.echo(f"   - {m}")
+    except json.JSONDecodeError:
+        click.echo(result)
+
+
+# Configuration management group
+@voice_mode_main_cli.group()
+def config():
+    """Manage voice-mode configuration."""
+    pass
+
+
+@config.command("list")
+def config_list():
+    """List all configuration keys with their descriptions."""
+    result = asyncio.run(list_config_keys.fn())
+    click.echo(result)
+
+
+@config.command("get")
+@click.argument('key')
+def config_get(key):
+    """Get a configuration value."""
+    import os
+    from pathlib import Path
+    
+    # Read from the env file
+    env_file = Path.home() / ".voicemode" / "voicemode.env"
+    if not env_file.exists():
+        click.echo(f"❌ Configuration file not found: {env_file}")
+        return
+    
+    # Look for the key
+    found = False
+    with open(env_file, 'r') as f:
+        for line in f:
+            line = line.strip()
+            if line.startswith('#') or not line:
+                continue
+            if '=' in line:
+                k, v = line.split('=', 1)
+                if k.strip() == key:
+                    click.echo(f"{key}={v.strip()}")
+                    found = True
+                    break
+    
+    if not found:
+        # Check environment variable
+        env_value = os.getenv(key)
+        if env_value is not None:
+            click.echo(f"{key}={env_value} (from environment)")
+        else:
+            click.echo(f"❌ Configuration key not found: {key}")
+            click.echo("Run 'voice-mode config list' to see available keys")
+
+
+@config.command("set")
+@click.argument('key')
+@click.argument('value')
+def config_set(key, value):
+    """Set a configuration value."""
+    result = asyncio.run(update_config.fn(key, value))
+    click.echo(result)
+
+
+# Diagnostics group
+@voice_mode_main_cli.group()
+def diag():
+    """Diagnostic tools for voice-mode."""
+    pass
+
+
+@diag.command()
+def info():
+    """Show voice-mode installation information."""
+    result = asyncio.run(voice_mode_info.fn())
+    click.echo(result)
+
+
+@diag.command()
+def devices():
+    """List available audio input and output devices."""
+    result = asyncio.run(check_audio_devices.fn())
+    click.echo(result)
+
+
+@diag.command()
+def registry():
+    """Show voice provider registry with all discovered endpoints."""
+    result = asyncio.run(voice_registry.fn())
+    click.echo(result)
+
+
+@diag.command()
+def dependencies():
+    """Check system audio dependencies and provide installation guidance."""
+    import json
+    result = asyncio.run(check_audio_dependencies.fn())
+    
+    if isinstance(result, dict):
+        # Format the dictionary output nicely
+        click.echo("System Audio Dependencies Check")
+        click.echo("=" * 50)
+        
+        click.echo(f"\nPlatform: {result.get('platform', 'Unknown')}")
+        
+        if 'packages' in result:
+            click.echo("\nSystem Packages:")
+            for pkg, status in result['packages'].items():
+                symbol = "✅" if status else "❌"
+                click.echo(f"  {symbol} {pkg}")
+        
+        if 'missing_packages' in result and result['missing_packages']:
+            click.echo("\n❌ Missing Packages:")
+            for pkg in result['missing_packages']:
+                click.echo(f"  - {pkg}")
+            if 'install_command' in result:
+                click.echo(f"\nInstall with: {result['install_command']}")
+        
+        if 'pulseaudio' in result:
+            pa = result['pulseaudio']
+            click.echo(f"\nPulseAudio Status: {'✅ Running' if pa.get('running') else '❌ Not running'}")
+            if pa.get('version'):
+                click.echo(f"  Version: {pa['version']}")
+        
+        if 'diagnostics' in result and result['diagnostics']:
+            click.echo("\nDiagnostics:")
+            for diag in result['diagnostics']:
+                click.echo(f"  - {diag}")
+        
+        if 'recommendations' in result and result['recommendations']:
+            click.echo("\nRecommendations:")
+            for rec in result['recommendations']:
+                click.echo(f"  - {rec}")
+    else:
+        # Fallback for string output
+        click.echo(str(result))
+
+
+# Legacy CLI for voice-mode-cli command
+@click.group()
+@click.version_option()
+@click.help_option('-h', '--help')
+def cli():
+    """Voice Mode CLI - Manage conversations, view logs, and analyze voice interactions."""
+    pass
+
+
+# Import subcommand groups
+from voice_mode.cli_commands import exchanges as exchanges_cmd
+
+# Add subcommands to legacy CLI
+cli.add_command(exchanges_cmd.exchanges)
+
+# Add exchanges to main CLI
+voice_mode_main_cli.add_command(exchanges_cmd.exchanges)
+
+

voice_mode-2.20.1/voice_mode/cli.py

@@ -1,28 +0,0 @@
-"""
-CLI entry points for voice-mode package.
-"""
-import sys
-import click
-from .server import main as voice_mode_main
-
-def voice_mode() -> None:
-    """Entry point for voicemode command - starts the MCP server."""
-    voice_mode_main()
-
-
-# New Click-based CLI
-@click.group()
-@click.version_option()
-@click.help_option('-h', '--help')
-def cli():
-    """Voice Mode CLI - Manage conversations, view logs, and analyze voice interactions."""
-    pass
-
-
-# Import subcommand groups
-from voice_mode.cli_commands import exchanges as exchanges_cmd
-
-# Add subcommands
-cli.add_command(exchanges_cmd.exchanges)
-
-