voice-server-https.py

#!/usr/bin/env python3
"""
HTTPS Cloud TTS Server for Simba Voice Chat (ElevenLabs)
"""

import os
import sys
import http.client
import json
import ssl
from http.server import HTTPServer, BaseHTTPRequestHandler

PORT = 8443  # HTTPS port
ELEVENLABS_API_KEY = "sk_63d6d857580a365ef74774a4ad7b47ac1614da33c3214d9a"
DEFAULT_VOICE = "EXAVITQu4vr4xnSDxMaL"

class CloudTTSHandler(BaseHTTPRequestHandler):
    def log_message(self, format, *args):
        print(f"[{self.log_date_time_string()}] {format % args}")
    
    def send_cors_headers(self):
        self.send_header('Access-Control-Allow-Origin', '*')
        self.send_header('Access-Control-Allow-Methods', 'GET, POST, OPTIONS')
        self.send_header('Access-Control-Allow-Headers', 'Content-Type, Authorization')
    
    def do_OPTIONS(self):
        self.send_response(200)
        self.send_cors_headers()
        self.end_headers()
    
    def do_GET(self):
        if self.path == '/health':
            self.send_response(200)
            self.send_cors_headers()
            self.send_header('Content-Type', 'application/json')
            self.end_headers()
            self.wfile.write(json.dumps({"status": "ok", "tts": "elevenlabs-cloud"}).encode())
        elif self.path == '/' or self.path == '/index.html':
            self.serve_file('voice-chat-safari.html', 'text/html')
        elif self.path.endswith('.html'):
            self.serve_file(self.path[1:], 'text/html')
        else:
            self.send_response(404)
            self.end_headers()
    
    def serve_file(self, filename, content_type):
        try:
            filepath = os.path.join('/Users/shashank/.openclaw/workspace', filename)
            with open(filepath, 'rb') as f:
                content = f.read()
            self.send_response(200)
            self.send_cors_headers()
            self.send_header('Content-Type', content_type)
            self.send_header('Content-Length', len(content))
            self.end_headers()
            self.wfile.write(content)
        except FileNotFoundError:
            self.send_response(404)
            self.end_headers()
        except Exception as e:
            print(f"Error serving file: {e}")
            self.send_response(500)
            self.end_headers()
    
    def do_POST(self):
        if self.path == '/v1/tts':
            self.handle_tts()
        elif self.path == '/v1/chat':
            self.handle_chat()
        else:
            self.send_response(404)
            self.end_headers()
    
    def handle_tts(self):
        try:
            content_length = int(self.headers.get('Content-Length', 0))
            body = json.loads(self.rfile.read(content_length).decode())
            text = body.get('text', '')
            voice_id = body.get('voice_id', DEFAULT_VOICE)
            
            if not text:
                self.send_response(400)
                self.end_headers()
                return
            
            print(f"🎙️  Generating cloud TTS: {text[:50]}...")
            
            conn = http.client.HTTPSConnection("api.elevenlabs.io")
            headers = {
                'xi-api-key': ELEVENLABS_API_KEY,
                'Content-Type': 'application/json'
            }
            payload = json.dumps({
                'text': text,
                'model_id': 'eleven_multilingual_v2',
                'voice_settings': {
                    'stability': 0.5,
                    'similarity_boost': 0.75
                }
            })
            
            conn.request("POST", f"/v1/text-to-speech/{voice_id}", body=payload, headers=headers)
            response = conn.getresponse()
            
            if response.status != 200:
                error = response.read().decode()
                print(f"ElevenLabs error: {error}")
                self.send_response(500)
                self.end_headers()
                return
            
            audio_data = response.read()
            conn.close()
            
            self.send_response(200)
            self.send_cors_headers()
            self.send_header('Content-Type', 'audio/mpeg')
            self.send_header('Content-Length', len(audio_data))
            self.end_headers()
            self.wfile.write(audio_data)
            
            print(f"✅ Cloud TTS generated: {len(audio_data)} bytes")
            
        except Exception as e:
            print(f"TTS error: {e}")
            self.send_response(500)
            self.end_headers()
    
    def handle_chat(self):
        try:
            content_length = int(self.headers.get('Content-Length', 0))
            body = json.loads(self.rfile.read(content_length).decode())
            
            if 'message' in body:
                body = {
                    "model": "kimi-k2.5:cloud",
                    "messages": [{"role": "user", "content": body['message']}],
                    "stream": False
                }
            
            conn = http.client.HTTPConnection("127.0.0.1", 18789)
            headers = {'Content-Type': 'application/json', 'Authorization': 'Bearer ollama'}
            conn.request("POST", "/v1/chat/completions", body=json.dumps(body).encode(), headers=headers)
            response = conn.getresponse()
            
            self.send_response(response.status)
            self.send_cors_headers()
            self.send_header('Content-Type', 'application/json')
            self.end_headers()
            self.wfile.write(response.read())
            conn.close()
            
        except Exception as e:
            print(f"Chat error: {e}")
            self.send_response(503)
            self.end_headers()
            self.wfile.write(json.dumps({"error": "Gateway unavailable"}).encode())

def main():
    print("🚀 Simba HTTPS Cloud Voice Chat Server")
    print("=" * 40)
    print(f"\n🔒 HTTPS Server: https://localhost:{PORT}")
    print(f"   TTS: ElevenLabs Cloud")
    print(f"   Voice: Sarah (warm, professional)")
    print("\n⚠️  You'll see a security warning - click 'Visit Website'")
    print("-" * 40)
    
    # SSL context with self-signed cert
    context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
    context.load_cert_chain('/tmp/cert.pem', '/tmp/key.pem')
    
    server = HTTPServer(('127.0.0.1', PORT), CloudTTSHandler)
    server.socket = context.wrap_socket(server.socket, server_side=True)
    
    try:
        server.serve_forever()
    except KeyboardInterrupt:
        print("\n\n👋 Server stopped")
        server.shutdown()

if __name__ == '__main__':
    main()