antigravity-remote 3.1.0__py3-none-any.whl

antigravity_remote/__init__.py

@@ -0,0 +1,13 @@
+"""Antigravity Remote - Secure remote control via Telegram."""
+
+__version__ = "3.0.0"
+
+from .agent import LocalAgent, run_agent
+from .secrets import get_user_config, save_user_config
+
+__all__ = [
+    "LocalAgent",
+    "run_agent",
+    "get_user_config",
+    "save_user_config",
+]

antigravity_remote/__main__.py

@@ -0,0 +1,112 @@
+"""CLI entry point for Antigravity Remote (Secure Version)."""
+
+import argparse
+import asyncio
+import logging
+import sys
+
+from .agent import run_agent
+from .secrets import get_user_config, save_user_config, clear_user_config, get_user_config_path
+
+
+def setup_logging(verbose: bool = False) -> None:
+    level = logging.DEBUG if verbose else logging.INFO
+    logging.basicConfig(format='%(asctime)s - %(levelname)s - %(message)s', level=level)
+
+
+def register_user() -> None:
+    """Secure user registration."""
+    print("� Antigravity Remote - Secure Registration")
+    print()
+    print("To get your credentials:")
+    print("1. Open Telegram and message @antigravityrcbot")
+    print("2. Send /start - you'll see your ID and Auth Token")
+    print()
+    
+    user_id = input("Enter your Telegram User ID: ").strip()
+    if not user_id.isdigit():
+        print("❌ Invalid user ID. It should be a number.")
+        sys.exit(1)
+    
+    auth_token = input("Enter your Auth Token: ").strip()
+    if len(auth_token) != 32:
+        print("❌ Invalid auth token. Should be 32 characters.")
+        sys.exit(1)
+    
+    save_user_config(user_id, auth_token)
+    print(f"✅ Registered securely!")
+    print(f"   Config saved to: {get_user_config_path()}")
+    print()
+    print("Now run: antigravity-remote")
+
+
+def show_status() -> None:
+    config = get_user_config()
+    print("📊 Antigravity Remote - Status")
+    print()
+    if config:
+        print(f"✅ User ID: {config['user_id']}")
+        print(f"🔑 Auth Token: {config['auth_token'][:8]}...")
+    else:
+        print("❌ Not registered. Run: antigravity-remote --register")
+    print(f"📁 Config: {get_user_config_path()}")
+    print()
+    print("📱 Bot: @antigravityrcbot")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Secure remote control for Antigravity AI")
+    
+    parser.add_argument("--register", action="store_true", help="Register your credentials")
+    parser.add_argument("--status", action="store_true", help="Show registration status")
+    parser.add_argument("--unregister", action="store_true", help="Remove your registration")
+    parser.add_argument("--server", help="Custom server URL")
+    parser.add_argument("-v", "--verbose", action="store_true", help="Verbose logging")
+    parser.add_argument("--version", action="version", version="antigravity-remote 3.0.0")
+    
+    args = parser.parse_args()
+    
+    if args.register:
+        register_user()
+        return
+    
+    if args.status:
+        show_status()
+        return
+    
+    if args.unregister:
+        clear_user_config()
+        print("✅ Unregistered.")
+        return
+    
+    setup_logging(args.verbose)
+    
+    config = get_user_config()
+    if not config:
+        print("❌ Not registered!")
+        print()
+        print("Run: antigravity-remote --register")
+        sys.exit(1)
+    
+    user_id = config["user_id"]
+    auth_token = config["auth_token"]
+    
+    print("� Antigravity Remote Control (Secure)")
+    print(f"   User ID: {user_id}")
+    print(f"   Auth: {auth_token[:8]}...")
+    print(f"   Bot: @antigravityrcbot")
+    print()
+    print("📱 Open Telegram and message @antigravityrcbot to control your PC!")
+    print()
+    print("Press Ctrl+C to stop")
+    print()
+    
+    try:
+        asyncio.run(run_agent(user_id, auth_token, args.server))
+    except KeyboardInterrupt:
+        print("\n👋 Shutting down...")
+        sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

antigravity_remote/agent.py

@@ -0,0 +1,382 @@
+"""
+Local Agent for Antigravity Remote - SECURE VERSION
+Handles authentication and all commands including MEDIA (Voice, Photo, Files)
+"""
+
+import asyncio
+import base64
+import json
+import logging
+import os
+import time
+import hashlib
+import re
+from pathlib import Path
+
+import websockets
+
+from .utils import (
+    send_to_antigravity,
+    send_key_combo,
+    scroll_screen,
+    take_screenshot,
+    cleanup_screenshot,
+    focus_antigravity,
+)
+
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+DEFAULT_SERVER_URL = os.environ.get("ANTIGRAVITY_SERVER", "wss://antigravity-remote.onrender.com/ws")
+
+# OCR keywords
+APPROVAL_KEYWORDS = ["run command", "accept changes", "proceed", "approve", "allow", "confirm", "y/n"]
+DONE_KEYWORDS = ["anything else", "let me know", "task complete", "done!", "successfully", "finished"]
+ERROR_KEYWORDS = ["error:", "failed", "exception", "traceback", "cannot", "permission denied"]
+
+
+def sanitize_input(text: str, max_length: int = 4000) -> str:
+    """Sanitize input."""
+    if not text:
+        return ""
+    text = re.sub(r'[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]', '', text)
+    return text[:max_length]
+
+
+class LocalAgent:
+    """Secure local agent with authentication and media support."""
+    
+    def __init__(self, user_id: str, auth_token: str, server_url: str = None):
+        self.user_id = user_id
+        self.auth_token = auth_token
+        self.server_url = server_url or DEFAULT_SERVER_URL
+        self.websocket = None
+        self.running = False
+        self.watchdog_enabled = False
+        self.watchdog_task = None
+        self.last_screen_hash = None
+        self.idle_count = 0
+        
+        # Setup download dirs
+        self.downloads_dir = Path.home() / "Downloads" / "AntigravityRemote"
+        self.downloads_dir.mkdir(parents=True, exist_ok=True)
+    
+    async def connect(self):
+        url = f"{self.server_url}/{self.user_id}"
+        logger.info(f"🔌 Connecting to server...")
+        
+        try:
+            self.websocket = await websockets.connect(url)
+            
+            # Send authentication
+            auth_msg = json.dumps({"auth_token": self.auth_token})
+            await self.websocket.send(auth_msg)
+            
+            # Wait for strict auth response
+            try:
+                response = await asyncio.wait_for(self.websocket.recv(), timeout=10.0)
+                resp = json.loads(response)
+                if "error" in resp:
+                    logger.error(f"❌ Authentication failed: {resp['error']}")
+                    return False
+            except asyncio.TimeoutError:
+                 # Legacy server might not send response immediately, assume ok but warn
+                 logger.warning("⚠️ No auth response (legacy server?), assuming connected")
+            
+            logger.info("✅ Authenticated and connected!")
+            return True
+            
+        except Exception as e:
+            logger.error(f"❌ Connection failed: {e}")
+            return False
+    
+    async def send_alert(self, alert_type: str, text: str, include_screenshot: bool = False):
+        """Send alert to server."""
+        if not self.websocket:
+            return
+        
+        alert = {"type": "alert", "alert_type": alert_type, "text": text}
+        
+        if include_screenshot:
+            path = take_screenshot()
+            if path:
+                with open(path, "rb") as f:
+                    alert["image"] = base64.b64encode(f.read()).decode()
+                cleanup_screenshot(path)
+        
+        try:
+            await self.websocket.send(json.dumps(alert))
+        except Exception:
+            pass
+    
+    async def run_watchdog(self):
+        """Background watchdog loop."""
+        logger.info("🐕 Watchdog started")
+        last_alert_time = 0
+        
+        while self.watchdog_enabled:
+            await asyncio.sleep(5)
+            
+            try:
+                path = take_screenshot()
+                if not path:
+                    continue
+                
+                with open(path, "rb") as f:
+                    data = f.read()
+                    current_hash = hashlib.md5(data[:10000]).hexdigest()
+                
+                if current_hash == self.last_screen_hash:
+                    self.idle_count += 1
+                else:
+                    self.idle_count = 0
+                self.last_screen_hash = current_hash
+                
+                # Try OCR
+                try:
+                    import pytesseract
+                    from PIL import Image
+                    img = Image.open(path)
+                    text = pytesseract.image_to_string(img).lower()
+                    
+                    current_time = time.time()
+                    if current_time - last_alert_time > 30:
+                        for kw in APPROVAL_KEYWORDS:
+                            if kw in text:
+                                await self.send_alert("approval", f"🚨 *Approval needed!*\nDetected: `{kw}`", True)
+                                last_alert_time = current_time
+                                break
+                        
+                        for kw in DONE_KEYWORDS:
+                            if kw in text:
+                                await self.send_alert("done", f"✅ *Task complete!*\nDetected: `{kw}`", True)
+                                last_alert_time = current_time
+                                break
+                        
+                        for kw in ERROR_KEYWORDS:
+                            if kw in text:
+                                await self.send_alert("error", f"⚠️ *Error detected!*\nDetected: `{kw}`", True)
+                                last_alert_time = current_time
+                                break
+                except ImportError:
+                    pass
+                
+                cleanup_screenshot(path)
+                
+                if self.idle_count >= 3 and time.time() - last_alert_time > 60:
+                    await self.send_alert("idle", "💤 *Screen idle*", True)
+                    last_alert_time = time.time()
+                    self.idle_count = 0
+                    
+            except Exception as e:
+                logger.error(f"Watchdog error: {e}")
+        
+        logger.info("🐕 Watchdog stopped")
+    
+    def process_voice(self, audio_path: Path) -> str:
+        """Transcribe voice file using SpeechRecognition."""
+        try:
+            import speech_recognition as sr
+            from pydub import AudioSegment
+            
+            # Convert OGG to WAV
+            wav_path = audio_path.with_suffix('.wav')
+            sound = AudioSegment.from_ogg(str(audio_path))
+            sound.export(str(wav_path), format="wav")
+            
+            r = sr.Recognizer()
+            with sr.AudioFile(str(wav_path)) as source:
+                audio = r.record(source)
+                text = r.recognize_google(audio)
+                return text
+        except Exception as e:
+            logger.error(f"Transcription failed: {e}")
+            return ""
+
+    async def handle_command(self, command: dict) -> dict:
+        cmd_type = command.get("type")
+        message_id = command.get("message_id")
+        result = {"message_id": message_id, "success": False}
+        
+        try:
+            if cmd_type == "screenshot":
+                path = take_screenshot()
+                if path:
+                    with open(path, "rb") as f:
+                        result["image"] = base64.b64encode(f.read()).decode()
+                    cleanup_screenshot(path)
+                    result["success"] = True
+            
+            elif cmd_type == "relay":
+                text = sanitize_input(command.get("text", ""))
+                result["success"] = send_to_antigravity(text)
+            
+            elif cmd_type == "photo":
+                try:
+                    data = base64.b64decode(command.get("data", ""))
+                    filename = f"photo_{int(time.time())}.jpg"
+                    path = self.downloads_dir / filename
+                    path.write_bytes(data)
+                    
+                    # Tell Agent
+                    send_to_antigravity(f"I uploaded a photo here: {path}")
+                    result["success"] = True
+                except Exception as e:
+                    result["error"] = str(e)
+            
+            elif cmd_type == "voice":
+                try:
+                    data = base64.b64decode(command.get("data", ""))
+                    filename = f"voice_{int(time.time())}.ogg"
+                    path = self.downloads_dir / filename
+                    path.write_bytes(data)
+                    
+                    # Try transcribe
+                    text = self.process_voice(path)
+                    if text:
+                        send_to_antigravity(f"(Voice Command): {text}")
+                        result["text"] = text
+                    else:
+                        send_to_antigravity(f"I sent a voice note here: {path}")
+                        result["text"] = "Audio saved (transcription failed)"
+                    
+                    result["success"] = True
+                except Exception as e:
+                    result["error"] = str(e)
+            
+            elif cmd_type == "file":
+                try:
+                    data = base64.b64decode(command.get("data", ""))
+                    name = sanitize_input(command.get("name", "file"), 100)
+                    path = Path.cwd() / name  # Save to CWD
+                    path.write_bytes(data)
+                    
+                    send_to_antigravity(f"I saved a file: {path.absolute()}")
+                    result["path"] = str(path.absolute())
+                    result["success"] = True
+                except Exception as e:
+                    result["error"] = str(e)
+
+            elif cmd_type == "scroll":
+                direction = command.get("direction", "down")
+                clicks = {"up": 25, "down": -25, "top": 500, "bottom": -500}.get(direction, -25)
+                result["success"] = scroll_screen(clicks)
+            
+            elif cmd_type == "key":
+                combo = sanitize_input(command.get("combo", ""), 50).split("+")
+                result["success"] = send_key_combo(combo)
+            
+            elif cmd_type == "accept":
+                import pyautogui
+                focus_antigravity()
+                time.sleep(0.2)
+                pyautogui.hotkey('alt', 'enter')
+                result["success"] = True
+            
+            elif cmd_type == "reject":
+                import pyautogui
+                focus_antigravity()
+                time.sleep(0.2)
+                pyautogui.press('escape')
+                result["success"] = True
+            
+            elif cmd_type == "undo":
+                import pyautogui
+                focus_antigravity()
+                pyautogui.hotkey('ctrl', 'z')
+                result["success"] = True
+            
+            elif cmd_type == "cancel":
+                import pyautogui
+                focus_antigravity()
+                pyautogui.press('escape')
+                result["success"] = True
+            
+            elif cmd_type == "model":
+                import pyautogui
+                model = sanitize_input(command.get("model", ""), 100)
+                focus_antigravity()
+                time.sleep(0.5)
+                
+                # Strategy 1: Ctrl + / (Common Cursor shortcut)
+                pyautogui.hotkey('ctrl', '/')
+                time.sleep(0.5)
+                pyautogui.write(model, interval=0.05)
+                time.sleep(0.5)
+                pyautogui.press('enter')
+                
+                # Strategy 2: Just tell the Agent!
+                time.sleep(0.5)
+                send_to_antigravity(f"Please switch model to {model}")
+                result["success"] = True
+            
+            elif cmd_type == "watchdog":
+                enabled = command.get("enabled", False)
+                self.watchdog_enabled = enabled
+                if enabled and not self.watchdog_task:
+                    self.watchdog_task = asyncio.create_task(self.run_watchdog())
+                elif not enabled and self.watchdog_task:
+                    self.watchdog_task.cancel()
+                    self.watchdog_task = None
+                result["success"] = True
+            
+            elif cmd_type == "sysinfo":
+                import psutil
+                cpu = psutil.cpu_percent(interval=1)
+                mem = psutil.virtual_memory()
+                result["info"] = f"CPU: {cpu}%\nRAM: {mem.percent}%"
+                result["success"] = True
+            
+            elif cmd_type == "files":
+                workspace = os.getcwd()
+                items = os.listdir(workspace)[:20]
+                result["files"] = "\n".join(f"📄 {i}" for i in items)
+                result["success"] = True
+            
+            else:
+                logger.warning(f"Unknown command: {cmd_type}")
+                
+        except Exception as e:
+            logger.error(f"Command error: {e}")
+            result["error"] = "Command failed"
+        
+        return result
+    
+    async def run(self):
+        self.running = True
+        reconnect_delay = 5
+        
+        while self.running:
+            try:
+                if not await self.connect():
+                    logger.info(f"Retrying in {reconnect_delay}s...")
+                    await asyncio.sleep(reconnect_delay)
+                    continue
+                
+                reconnect_delay = 5
+                
+                async for message in self.websocket:
+                    command = json.loads(message)
+                    logger.info(f"📥 Received: {command.get('type')}")
+                    result = await self.handle_command(command)
+                    await self.websocket.send(json.dumps(result))
+                    
+            except websockets.exceptions.ConnectionClosed:
+                logger.warning("Connection closed. Reconnecting...")
+                await asyncio.sleep(reconnect_delay)
+                reconnect_delay = min(reconnect_delay * 2, 60)
+            except Exception as e:
+                logger.error(f"Error: {e}")
+                await asyncio.sleep(reconnect_delay)
+    
+    def stop(self):
+        self.running = False
+        self.watchdog_enabled = False
+        if self.websocket:
+            asyncio.create_task(self.websocket.close())
+
+
+async def run_agent(user_id: str, auth_token: str, server_url: str = None):
+    """Run the secure local agent."""
+    agent = LocalAgent(user_id, auth_token, server_url)
+    await agent.run()

antigravity_remote/bot.py

@@ -0,0 +1,168 @@
+"""Main bot class for Antigravity Remote."""
+
+import asyncio
+import logging
+import sys
+
+from telegram import Update
+from telegram.ext import (
+    ApplicationBuilder,
+    CommandHandler,
+    CallbackQueryHandler,
+    MessageHandler,
+    filters,
+)
+
+from .config import config
+from .state import state
+from .handlers import (
+    # Control
+    start_command,
+    pause_command,
+    resume_command,
+    cancel_command,
+    key_command,
+    lock_command,
+    unlock_command,
+    # Screen
+    status_command,
+    scroll_command,
+    accept_command,
+    reject_command,
+    undo_command,
+    # Files
+    sysinfo_command,
+    files_command,
+    read_command,
+    diff_command,
+    log_command,
+    # Monitoring
+    heartbeat_command,
+    watchdog_command,
+    schedule_command,
+    # AI
+    model_command,
+    summary_command,
+    handle_message,
+    handle_model_callback,
+    # Quick
+    quick_replies_command,
+    handle_quick_callback,
+    handle_voice,
+)
+from .utils import take_screenshot, cleanup_screenshot
+from .handlers.base import is_authorized
+
+logger = logging.getLogger(__name__)
+
+
+class AntigravityBot:
+    """Main Antigravity Remote Control bot."""
+    
+    def __init__(self):
+        """Initialize the bot using embedded token and registered user."""
+        self.token = config.bot_token
+        self.user_id = config.allowed_user_id
+        self.application = None
+    
+    def validate(self) -> bool:
+        """Validate configuration before starting."""
+        errors = config.validate()
+        
+        if errors:
+            for error in errors:
+                logger.error(f"Configuration error: {error}")
+            return False
+        
+        return True
+    
+    async def button_handler(self, update: Update, context) -> None:
+        """Handle all callback button presses."""
+        query = update.callback_query
+        await query.answer()
+        
+        if not await is_authorized(update):
+            return
+        
+        data = query.data
+        
+        if data == "screenshot":
+            await query.message.reply_text("📸 Capturing...")
+            path = await asyncio.to_thread(take_screenshot)
+            if path:
+                await context.bot.send_photo(
+                    chat_id=update.effective_chat.id,
+                    photo=open(path, 'rb')
+                )
+                cleanup_screenshot(path)
+        
+        elif data.startswith("model_"):
+            model_id = data.replace("model_", "")
+            await handle_model_callback(query, context, model_id)
+        
+        elif data.startswith("quick_"):
+            action = data.replace("quick_", "")
+            await handle_quick_callback(query, context, action)
+    
+    def setup_handlers(self) -> None:
+        """Register all command and message handlers."""
+        app = self.application
+        
+        # Command handlers
+        handlers = [
+            ("start", start_command),
+            ("status", status_command),
+            ("pause", pause_command),
+            ("resume", resume_command),
+            ("cancel", cancel_command),
+            ("scroll", scroll_command),
+            ("accept", accept_command),
+            ("reject", reject_command),
+            ("undo", undo_command),
+            ("sysinfo", sysinfo_command),
+            ("files", files_command),
+            ("read", read_command),
+            ("diff", diff_command),
+            ("log", log_command),
+            ("lock", lock_command),
+            ("unlock", unlock_command),
+            ("heartbeat", heartbeat_command),
+            ("key", key_command),
+            ("schedule", schedule_command),
+            ("watchdog", watchdog_command),
+            ("model", model_command),
+            ("quick", quick_replies_command),
+            ("summary", summary_command),
+        ]
+        
+        for command, handler in handlers:
+            app.add_handler(CommandHandler(command, handler))
+        
+        # Callback handlers
+        app.add_handler(CallbackQueryHandler(self.button_handler))
+        
+        # Message handlers
+        app.add_handler(MessageHandler(filters.VOICE, handle_voice))
+        app.add_handler(MessageHandler(filters.TEXT & (~filters.COMMAND), handle_message))
+    
+    def run(self) -> None:
+        """Start the bot."""
+        if not self.validate():
+            logger.error("Configuration validation failed")
+            sys.exit(1)
+        
+        self.application = ApplicationBuilder().token(self.token).build()
+        self.setup_handlers()
+        
+        print("🚀 Antigravity Remote Control")
+        print(f"   User: {self.user_id}")
+        print(f"   Workspace: {config.workspace_path}")
+        print()
+        
+        self.application.run_polling()
+    
+    def stop(self) -> None:
+        """Stop the bot and cleanup."""
+        state.cancel_tasks()
+        if self.application:
+            self.application.stop()