mac_daemon_network.py

#!/usr/bin/env python3
"""
VM-to-Host Command Bridge Daemon - Network Version
Binds to network interface for direct VM access
Supports bidirectional agent communication
"""

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 bidirectional support
COMMANDS = {
    # Clipboard operations
    'pbcopy': {
        'binary': '/usr/bin/pbcopy',
        'allow_stdin': True,
        'max_stdin_size': 50 * 1024 * 1024,  # 50MB for large files
        'description': 'Copy to Mac clipboard'
    },
    'pbpaste': {
        'binary': '/usr/bin/pbpaste', 
        'allow_stdout': True,
        'description': 'Paste from Mac clipboard'
    },
    
    # File operations
    'save_file': {
        'handler': 'save_file_handler',
        'description': 'Save file from VM to Mac'
    },
    'read_file': {
        'handler': 'read_file_handler',
        'description': 'Read file from Mac to VM'
    },
    
    # Agent communication
    'run_agent': {
        'handler': 'run_agent_handler',
        'description': 'Run Claude agent on Mac with context'
    },
    'send_task': {
        'handler': 'send_task_handler',
        'description': 'Send task to Mac Claude'
    },
    
    # System operations
    'notify': {
        'binary': '/usr/bin/osascript',
        'allow_args': True,
        'args_template': ['-e', 'display notification "{message}" with title "VM Agent"'],
        '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'
    },
    'snapshot': {
        'handler': 'snapshot_handler',
        'description': 'Create VM snapshot'
    }
}

class CommandHandler:
    """Handle command execution with custom handlers"""
    
    @staticmethod
    def save_file_handler(request):
        """Save file from VM to Mac"""
        try:
            path = os.path.expanduser(request.get('path', '~/Desktop/vm_file.txt'))
            content = request.get('content', '')
            
            os.makedirs(os.path.dirname(path), exist_ok=True)
            with open(path, 'w') as f:
                f.write(content)
            
            return {
                'success': True,
                'message': f'File saved to {path}',
                'path': path
            }
        except Exception as e:
            return {'success': False, 'error': str(e)}
    
    @staticmethod
    def read_file_handler(request):
        """Read file from Mac"""
        try:
            path = os.path.expanduser(request.get('path'))
            with open(path, 'r') as f:
                content = f.read()
            
            return {
                'success': True,
                'content': content,
                'size': len(content)
            }
        except Exception as e:
            return {'success': False, 'error': str(e)}
    
    @staticmethod
    def run_agent_handler(request):
        """Run Claude agent on Mac with provided context"""
        try:
            prompt = request.get('prompt', '')
            context = request.get('context', '')
            
            # Create a command for Claude on Mac
            claude_cmd = f"claude '{prompt}'"
            
            # Save context to temp file if provided
            if context:
                context_file = '/tmp/vm_context.md'
                with open(context_file, 'w') as f:
                    f.write(context)
                claude_cmd = f"claude '@{context_file} {prompt}'"
            
            # Run Claude
            result = subprocess.run(
                claude_cmd,
                shell=True,
                capture_output=True,
                text=True,
                timeout=30
            )
            
            return {
                'success': result.returncode == 0,
                'output': result.stdout,
                'error': result.stderr
            }
        except Exception as e:
            return {'success': False, 'error': str(e)}
    
    @staticmethod
    def send_task_handler(request):
        """Queue task for Mac Claude"""
        try:
            task = request.get('task', '')
            priority = request.get('priority', 'normal')
            
            # Save task to queue file
            task_file = os.path.expanduser('~/Documents/vm_tasks.json')
            
            tasks = []
            if os.path.exists(task_file):
                with open(task_file, 'r') as f:
                    tasks = json.load(f)
            
            tasks.append({
                'task': task,
                'priority': priority,
                'timestamp': datetime.now().isoformat(),
                'from': 'VM'
            })
            
            with open(task_file, 'w') as f:
                json.dump(tasks, f, indent=2)
            
            # Notify
            subprocess.run([
                'osascript', '-e',
                f'display notification "New task from VM" with title "Agent Bridge"'
            ])
            
            return {
                'success': True,
                'message': 'Task queued',
                'queue_length': len(tasks)
            }
        except Exception as e:
            return {'success': False, 'error': str(e)}
    
    @staticmethod
    def snapshot_handler(request):
        """Create VM snapshot"""
        try:
            name = request.get('name', f"snapshot_{datetime.now().strftime('%Y%m%d_%H%M%S')}")
            
            # Try Parallels first
            result = subprocess.run(
                ['prlctl', 'snapshot', 'Ubuntu', '-n', name],
                capture_output=True,
                text=True
            )
            
            if result.returncode != 0:
                # Try VirtualBox
                result = subprocess.run(
                    ['VBoxManage', 'snapshot', 'Ubuntu', 'take', name],
                    capture_output=True,
                    text=True
                )
            
            return {
                'success': result.returncode == 0,
                'message': f'Snapshot {name} created' if result.returncode == 0 else result.stderr
            }
        except Exception as e:
            return {'success': False, 'error': str(e)}
    
    @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]
            
            # Use custom handler if specified
            if 'handler' in config:
                handler_name = config['handler']
                handler = getattr(CommandHandler, handler_name)
                return handler(request)
            
            # Otherwise use standard binary execution
            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'}
            
            cmd = [config['binary']]
            
            if config.get('allow_args'):
                args = request.get('args', [])
                if config.get('args_template'):
                    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)
                else:
                    cmd.extend(args)
            
            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 Exception as e:
            logging.error(f"Command execution error: {e}")
            return {'success': False, 'error': str(e)}

class ClientHandler(threading.Thread):
    """Handle client connections"""
    def __init__(self, client_socket, address):
        super().__init__()
        self.client = client_socket
        self.address = address
        self.daemon = True
        
    def run(self):
        try:
            data = b''
            while True:
                chunk = self.client.recv(4096)
                if not chunk:
                    break
                data += chunk
                if len(data) > 50 * 1024 * 1024:  # 50MB max
                    raise ValueError("Request too large")
                try:
                    json.loads(data.decode('utf-8'))
                    break
                except:
                    continue
            
            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}")
            
            result = CommandHandler.execute(request)
            result['id'] = request_id
            
            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 - network version"""
    
    def __init__(self, host='0.0.0.0', port=9999):
        """Bind to all interfaces for VM access"""
        self.host = host  # 0.0.0.0 allows VM connection
        self.port = port
        self.socket = None
        self.running = False
        
    def start(self):
        try:
            self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
            self.socket.bind((self.host, self.port))
            self.socket.listen(5)
            
            self.running = True
            
            # Get actual IP for display
            import subprocess
            ip_result = subprocess.run(['ipconfig', 'getifaddr', 'en0'], 
                                     capture_output=True, text=True)
            mac_ip = ip_result.stdout.strip() or 'unknown'
            
            logging.info(f"VM Bridge Daemon started on {self.host}:{self.port}")
            print(f"🌉 VM Bridge Daemon (Network Version)")
            print(f"=" * 50)
            print(f"✅ Listening on all interfaces: {self.host}:{self.port}")
            print(f"📍 Mac IP: {mac_ip}")
            print(f"🔌 VM can connect to: {mac_ip}:{self.port}")
            print(f"📝 Logs: ~/Library/Logs/vm-bridge.log")
            print(f"")
            print(f"Available commands:")
            for cmd, config in COMMANDS.items():
                print(f"  • {cmd}: {config['description']}")
            print(f"")
            print(f"VM clients should connect to {mac_ip}:{self.port}")
            
            while self.running:
                try:
                    client, address = self.socket.accept()
                    # Only accept from local network
                    if address[0].startswith(('127.', '10.', '192.168.', '172.')):
                        handler = ClientHandler(client, address)
                        handler.start()
                    else:
                        logging.warning(f"Rejected connection from {address}")
                        client.close()
                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):
        self.running = False
        if self.socket:
            self.socket.close()
        logging.info("VM Bridge Daemon stopped")
        print("\n👋 VM Bridge Daemon stopped")

def main():
    print("=" * 50)
    print("VM-to-Host Agent Bridge (Network Version)")
    print("=" * 50)
    
    daemon = VMBridgeDaemon()
    
    try:
        daemon.start()
    except KeyboardInterrupt:
        daemon.stop()

if __name__ == '__main__':
    main()