mac_daemon.py

#!/usr/bin/env python3
"""
VM-to-Host Command Bridge Daemon
Runs on Mac host, accepts commands from VM via reverse SSH tunnel
"""

import socket
import json
import subprocess
import threading
import logging
import sys
import os
from datetime import datetime

# Configure logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler(os.path.expanduser('~/Library/Logs/vm-bridge.log')),
        logging.StreamHandler()
    ]
)

# Command whitelist with configuration
COMMANDS = {
    'pbcopy': {
        'binary': '/usr/bin/pbcopy',
        'allow_stdin': True,
        'allow_args': False,
        'max_stdin_size': 10 * 1024 * 1024,  # 10MB max
        'description': 'Copy to Mac clipboard'
    },
    'pbpaste': {
        'binary': '/usr/bin/pbpaste',
        'allow_stdout': True,
        'allow_args': False,
        'description': 'Paste from Mac clipboard'
    },
    'notify': {
        'binary': '/usr/bin/osascript',
        'allow_args': True,
        'args_template': ['-e', 'display notification "{message}" with title "VM Bridge"'],
        'description': 'Show Mac notification'
    },
    'open_url': {
        'binary': '/usr/bin/open',
        'allow_args': True,
        'args_validator': lambda args: len(args) == 1 and args[0].startswith(('http://', 'https://')),
        'description': 'Open URL in Mac browser'
    }
}

class CommandHandler:
    """Handle individual command execution"""
    
    @staticmethod
    def execute(request):
        """Execute a whitelisted command"""
        try:
            cmd_name = request.get('cmd')
            if not cmd_name or cmd_name not in COMMANDS:
                return {
                    'success': False,
                    'error': f'Unknown command: {cmd_name}'
                }
            
            config = COMMANDS[cmd_name]
            
            # Validate stdin size if provided
            stdin_data = request.get('stdin', '')
            if stdin_data and config.get('allow_stdin'):
                max_size = config.get('max_stdin_size', float('inf'))
                if len(stdin_data) > max_size:
                    return {
                        'success': False,
                        'error': f'Stdin too large: {len(stdin_data)} > {max_size}'
                    }
            elif stdin_data and not config.get('allow_stdin'):
                return {
                    'success': False,
                    'error': f'Command {cmd_name} does not accept stdin'
                }
            
            # Build command
            cmd = [config['binary']]
            
            # Handle arguments
            if config.get('allow_args'):
                args = request.get('args', [])
                if config.get('args_template'):
                    # Use template (for notify)
                    template = config['args_template'].copy()
                    for i, arg in enumerate(template):
                        if '{message}' in arg and args:
                            template[i] = arg.replace('{message}', args[0])
                    cmd.extend(template)
                elif config.get('args_validator'):
                    # Validate args
                    if config['args_validator'](args):
                        cmd.extend(args)
                    else:
                        return {
                            'success': False,
                            'error': 'Invalid arguments'
                        }
                else:
                    cmd.extend(args)
            
            # Execute command
            process = subprocess.Popen(
                cmd,
                stdin=subprocess.PIPE if stdin_data else None,
                stdout=subprocess.PIPE,
                stderr=subprocess.PIPE,
                text=True
            )
            
            stdout, stderr = process.communicate(
                input=stdin_data if stdin_data else None,
                timeout=request.get('timeout', 5)
            )
            
            return {
                'success': process.returncode == 0,
                'stdout': stdout if config.get('allow_stdout') else '',
                'stderr': stderr,
                'exit_code': process.returncode
            }
            
        except subprocess.TimeoutExpired:
            return {
                'success': False,
                'error': 'Command timed out'
            }
        except Exception as e:
            logging.error(f"Command execution error: {e}")
            return {
                'success': False,
                'error': str(e)
            }

class ClientHandler(threading.Thread):
    """Handle individual client connections"""
    
    def __init__(self, client_socket, address):
        super().__init__()
        self.client = client_socket
        self.address = address
        self.daemon = True
        
    def run(self):
        """Handle client request"""
        try:
            # Receive data (up to 10MB)
            data = b''
            while True:
                chunk = self.client.recv(4096)
                if not chunk:
                    break
                data += chunk
                if len(data) > 10 * 1024 * 1024:
                    raise ValueError("Request too large")
                # Check if we have a complete JSON object
                try:
                    json.loads(data.decode('utf-8'))
                    break  # Valid JSON, we have the complete message
                except:
                    continue  # Keep reading
            
            # Parse request
            request = json.loads(data.decode('utf-8'))
            request_id = request.get('id', 'unknown')
            
            logging.info(f"Request {request_id}: {request.get('cmd')} from {self.address}")
            
            # Execute command
            result = CommandHandler.execute(request)
            
            # Add request ID to response
            result['id'] = request_id
            
            # Send response
            response = json.dumps(result).encode('utf-8')
            self.client.send(response)
            
            logging.info(f"Request {request_id}: {'Success' if result.get('success') else 'Failed'}")
            
        except Exception as e:
            logging.error(f"Client handler error: {e}")
            error_response = json.dumps({
                'success': False,
                'error': str(e)
            }).encode('utf-8')
            try:
                self.client.send(error_response)
            except:
                pass
        finally:
            self.client.close()

class VMBridgeDaemon:
    """Main daemon class"""
    
    def __init__(self, host='127.0.0.1', port=9999):
        self.host = host
        self.port = port
        self.socket = None
        self.running = False
        
    def start(self):
        """Start the daemon"""
        try:
            # Create socket
            self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
            
            # Bind to localhost only for security
            self.socket.bind((self.host, self.port))
            self.socket.listen(5)
            
            self.running = True
            logging.info(f"VM Bridge Daemon started on {self.host}:{self.port}")
            print(f"🚀 VM Bridge Daemon listening on {self.host}:{self.port}")
            print(f"📝 Logs: ~/Library/Logs/vm-bridge.log")
            print(f"Available commands: {', '.join(COMMANDS.keys())}")
            
            # Accept connections
            while self.running:
                try:
                    client, address = self.socket.accept()
                    handler = ClientHandler(client, address)
                    handler.start()
                except KeyboardInterrupt:
                    break
                except Exception as e:
                    logging.error(f"Accept error: {e}")
                    
        except Exception as e:
            logging.error(f"Daemon start error: {e}")
            print(f"❌ Failed to start daemon: {e}")
            sys.exit(1)
        finally:
            self.stop()
    
    def stop(self):
        """Stop the daemon"""
        self.running = False
        if self.socket:
            self.socket.close()
        logging.info("VM Bridge Daemon stopped")
        print("\n👋 VM Bridge Daemon stopped")

def main():
    """Main entry point"""
    print("=" * 50)
    print("VM-to-Host Command Bridge Daemon")
    print("=" * 50)
    
    daemon = VMBridgeDaemon()
    
    try:
        daemon.start()
    except KeyboardInterrupt:
        print("\nShutting down...")
        daemon.stop()

if __name__ == '__main__':
    main()