antigravity-remote 3.1.0__py3-none-any.whl

antigravity_remote/handlers/monitoring.py

@@ -0,0 +1,199 @@
+"""Monitoring command handlers for Antigravity Remote."""
+
+import asyncio
+import logging
+import time
+from datetime import datetime
+
+from telegram import Update
+from telegram.ext import ContextTypes
+from telegram.constants import ParseMode
+
+from .base import is_authorized
+from ..config import config
+from ..state import state
+from ..utils import take_screenshot, cleanup_screenshot, scan_screen, detect_keywords
+
+logger = logging.getLogger(__name__)
+
+
+async def heartbeat_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    """Start/stop heartbeat screenshots."""
+    if not await is_authorized(update):
+        return
+    
+    args = context.args
+    
+    # Cancel existing heartbeat
+    if state.heartbeat_task:
+        state.heartbeat_task.cancel()
+        state.heartbeat_task = None
+    
+    if not args or args[0] == "off":
+        await update.message.reply_text("💓 Heartbeat stopped.")
+        return
+    
+    try:
+        minutes = int(args[0])
+    except ValueError:
+        await update.message.reply_text("Usage: /heartbeat <minutes> or /heartbeat off")
+        return
+    
+    async def heartbeat_loop():
+        while True:
+            await asyncio.sleep(minutes * 60)
+            path = await asyncio.to_thread(take_screenshot)
+            if path:
+                await context.bot.send_photo(
+                    chat_id=update.effective_chat.id,
+                    photo=open(path, 'rb'),
+                    caption=f"💓 Heartbeat - {datetime.now().strftime('%H:%M')}"
+                )
+                cleanup_screenshot(path)
+    
+    state.heartbeat_task = asyncio.create_task(heartbeat_loop())
+    await update.message.reply_text(f"💓 Heartbeat started! Screenshot every {minutes} minutes.")
+
+
+async def watchdog_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    """Start/stop smart watchdog monitoring."""
+    if not await is_authorized(update):
+        return
+    
+    args = context.args
+    
+    # Cancel existing watchdog
+    if state.watchdog_task:
+        state.watchdog_task.cancel()
+        state.watchdog_task = None
+    
+    if args and args[0] == "off":
+        await update.message.reply_text("🐕 Watchdog stopped.")
+        return
+    
+    check_interval = config.watchdog_interval
+    alert_cooldown = config.alert_cooldown
+    
+    async def watchdog_loop():
+        while True:
+            await asyncio.sleep(check_interval)
+            
+            try:
+                screen_text, current_hash = await asyncio.to_thread(scan_screen)
+                current_time = time.time()
+                
+                # Activity monitoring
+                if current_hash == state.watchdog_last_hash:
+                    state.watchdog_idle_count += 1
+                else:
+                    state.watchdog_idle_count = 0
+                state.watchdog_last_hash = current_hash
+                
+                # Check for keywords
+                detection = detect_keywords(screen_text)
+                
+                if detection and current_time - state.watchdog_last_alert > alert_cooldown:
+                    category, keyword = detection
+                    state.watchdog_last_alert = current_time
+                    
+                    path = await asyncio.to_thread(take_screenshot)
+                    if path:
+                        captions = {
+                            'approval': f"🚨 *Approval needed!*\nDetected: `{keyword}`",
+                            'done': f"✅ *Task appears complete!*\nDetected: `{keyword}`",
+                            'error': f"⚠️ *Error detected!*\nDetected: `{keyword}`",
+                        }
+                        
+                        await context.bot.send_photo(
+                            chat_id=update.effective_chat.id,
+                            photo=open(path, 'rb'),
+                            caption=captions.get(category, f"Detected: `{keyword}`"),
+                            parse_mode=ParseMode.MARKDOWN
+                        )
+                        cleanup_screenshot(path)
+                
+                # Idle detection (2+ cycles with no change)
+                if (state.watchdog_idle_count >= 2 and 
+                    current_time - state.watchdog_last_alert > 60):
+                    
+                    state.watchdog_last_alert = current_time
+                    state.watchdog_idle_count = 0
+                    
+                    path = await asyncio.to_thread(take_screenshot)
+                    if path:
+                        await context.bot.send_photo(
+                            chat_id=update.effective_chat.id,
+                            photo=open(path, 'rb'),
+                            caption="💤 *Screen idle* - No activity detected",
+                            parse_mode=ParseMode.MARKDOWN
+                        )
+                        cleanup_screenshot(path)
+                        
+            except Exception as e:
+                logger.error(f"Watchdog error: {e}")
+    
+    state.watchdog_task = asyncio.create_task(watchdog_loop())
+    
+    await update.message.reply_text(
+        "🐕 *Watchdog started!*\n\n"
+        "I'll alert you when:\n"
+        "• 🚨 Approval is needed\n"
+        "• ✅ Task appears complete\n"
+        "• ⚠️ Errors are detected\n"
+        "• 💤 Screen goes idle\n\n"
+        "Use `/watchdog off` to stop.",
+        parse_mode=ParseMode.MARKDOWN
+    )
+
+
+async def schedule_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    """Schedule a command for later."""
+    if not await is_authorized(update):
+        return
+    
+    args = context.args
+    if len(args) < 2:
+        await update.message.reply_text("Usage: /schedule 5m /status\nTime: 30s, 5m, 1h")
+        return
+    
+    time_str = args[0].lower()
+    scheduled_cmd = ' '.join(args[1:])
+    
+    # Parse time
+    try:
+        if time_str.endswith('s'):
+            seconds = int(time_str[:-1])
+        elif time_str.endswith('m'):
+            seconds = int(time_str[:-1]) * 60
+        elif time_str.endswith('h'):
+            seconds = int(time_str[:-1]) * 3600
+        else:
+            seconds = int(time_str)
+    except ValueError:
+        await update.message.reply_text("Invalid time format. Use: 30s, 5m, 1h")
+        return
+    
+    await update.message.reply_text(
+        f"⏰ Scheduled `{scheduled_cmd}` in {time_str}",
+        parse_mode=ParseMode.MARKDOWN
+    )
+    
+    async def run_scheduled():
+        await asyncio.sleep(seconds)
+        
+        if 'status' in scheduled_cmd.lower() or 'screenshot' in scheduled_cmd.lower():
+            path = await asyncio.to_thread(take_screenshot)
+            if path:
+                await context.bot.send_photo(
+                    chat_id=update.effective_chat.id,
+                    photo=open(path, 'rb'),
+                    caption="⏰ Scheduled screenshot"
+                )
+                cleanup_screenshot(path)
+        else:
+            await context.bot.send_message(
+                chat_id=update.effective_chat.id,
+                text=f"⏰ Timer complete for: {scheduled_cmd}"
+            )
+    
+    asyncio.create_task(run_scheduled())

antigravity_remote/handlers/quick.py

@@ -0,0 +1,135 @@
+"""Quick command handlers for Antigravity Remote."""
+
+import asyncio
+import logging
+import os
+import tempfile
+
+from telegram import Update, InlineKeyboardButton, InlineKeyboardMarkup
+from telegram.ext import ContextTypes
+from telegram.constants import ParseMode
+
+from .base import is_authorized
+from ..utils import send_to_antigravity, take_screenshot, cleanup_screenshot
+
+logger = logging.getLogger(__name__)
+
+# Quick reply options
+QUICK_REPLIES = [
+    ("✅ Yes", "quick_yes"),
+    ("❌ No", "quick_no"),
+    ("▶️ Proceed", "quick_proceed"),
+    ("⏹️ Cancel", "quick_cancel"),
+    ("👍 Approve", "quick_approve"),
+    ("⏭️ Skip", "quick_skip"),
+]
+
+QUICK_TEXTS = {
+    "quick_yes": "Yes",
+    "quick_no": "No",
+    "quick_proceed": "Proceed",
+    "quick_cancel": "Cancel",
+    "quick_approve": "Approve",
+    "quick_skip": "Skip",
+}
+
+
+async def quick_replies_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    """Show quick reply buttons."""
+    if not await is_authorized(update):
+        return
+    
+    keyboard = [
+        [InlineKeyboardButton("✅ Yes", callback_data="quick_yes"),
+         InlineKeyboardButton("❌ No", callback_data="quick_no")],
+        [InlineKeyboardButton("▶️ Proceed", callback_data="quick_proceed"),
+         InlineKeyboardButton("⏹️ Cancel", callback_data="quick_cancel")],
+        [InlineKeyboardButton("👍 Approve", callback_data="quick_approve"),
+         InlineKeyboardButton("⏭️ Skip", callback_data="quick_skip")],
+    ]
+    
+    await update.message.reply_text(
+        "⚡ *Quick Replies* - Tap to send:",
+        reply_markup=InlineKeyboardMarkup(keyboard),
+        parse_mode=ParseMode.MARKDOWN
+    )
+
+
+async def handle_quick_callback(
+    query,
+    context: ContextTypes.DEFAULT_TYPE,
+    action: str
+) -> None:
+    """Handle quick reply callback."""
+    text = QUICK_TEXTS.get(action, action.capitalize())
+    success = await asyncio.to_thread(send_to_antigravity, text)
+    
+    if success:
+        await query.message.reply_text(f"📤 Sent: *{text}*", parse_mode=ParseMode.MARKDOWN)
+    else:
+        await query.message.reply_text("❌ Failed to send")
+
+
+async def handle_voice(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    """Handle voice messages - download, transcribe, and relay."""
+    if not await is_authorized(update):
+        return
+    
+    voice = update.message.voice
+    status_msg = await update.message.reply_text("🎤 Processing voice message...")
+    
+    try:
+        # Download voice file
+        file = await context.bot.get_file(voice.file_id)
+        voice_path = os.path.join(tempfile.gettempdir(), f"voice_{voice.file_id}.ogg")
+        await file.download_to_drive(voice_path)
+        
+        # Try to transcribe with speech recognition
+        try:
+            import speech_recognition as sr
+            recognizer = sr.Recognizer()
+            
+            # Convert ogg to wav
+            wav_path = voice_path.replace('.ogg', '.wav')
+            os.system(f'ffmpeg -i "{voice_path}" -y "{wav_path}" 2>nul')
+            
+            with sr.AudioFile(wav_path) as source:
+                audio = recognizer.record(source)
+                text = recognizer.recognize_google(audio)
+            
+            # Cleanup
+            if os.path.exists(wav_path):
+                os.remove(wav_path)
+            if os.path.exists(voice_path):
+                os.remove(voice_path)
+            
+            # Relay transcribed text
+            await status_msg.edit_text(
+                f"🎤 Transcribed: *{text}*\n\nSending...",
+                parse_mode=ParseMode.MARKDOWN
+            )
+            success = await asyncio.to_thread(send_to_antigravity, text)
+            
+            if success:
+                keyboard = [[InlineKeyboardButton("📸 Get Result", callback_data="screenshot")]]
+                await status_msg.edit_text(
+                    f"✅ *Voice relayed:*\n`{text}`",
+                    reply_markup=InlineKeyboardMarkup(keyboard),
+                    parse_mode=ParseMode.MARKDOWN
+                )
+            else:
+                await status_msg.edit_text("❌ Failed to relay voice message")
+                
+        except ImportError:
+            await status_msg.edit_text(
+                "⚠️ Voice transcription not available.\n"
+                "Install: `pip install SpeechRecognition`",
+                parse_mode=ParseMode.MARKDOWN
+            )
+        except Exception as e:
+            await status_msg.edit_text(f"⚠️ Transcription failed: {e}")
+            if os.path.exists(voice_path):
+                os.remove(voice_path)
+                
+    except Exception as e:
+        await status_msg.edit_text(f"❌ Error processing voice: {e}")

antigravity_remote/handlers/screen.py

@@ -0,0 +1,108 @@
+"""Screen command handlers for Antigravity Remote."""
+
+import asyncio
+import logging
+import time
+
+import pyautogui
+
+from telegram import Update
+from telegram.ext import ContextTypes
+from telegram.constants import ParseMode
+
+from .base import is_authorized
+from ..utils import focus_antigravity, take_screenshot, cleanup_screenshot, scroll_screen
+
+logger = logging.getLogger(__name__)
+
+
+async def status_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    """Take and send a screenshot."""
+    if not await is_authorized(update):
+        return
+    
+    msg = await update.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'),
+            caption="🖥️ Current screen"
+        )
+        cleanup_screenshot(path)
+    else:
+        await update.message.reply_text("❌ Failed to capture screenshot")
+    
+    await msg.delete()
+
+
+async def scroll_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    """Scroll the screen."""
+    if not await is_authorized(update):
+        return
+    
+    args = context.args
+    direction = "down"
+    multiplier = 1
+    
+    # Parse args: /scroll up x50 or /scroll down 10 or /scroll bottom
+    for arg in args:
+        if arg == "bottom":
+            direction = "down"
+            multiplier = 100
+        elif arg == "top":
+            direction = "up"
+            multiplier = 100
+        elif arg in ["up", "down"]:
+            direction = arg
+        elif arg.startswith("x") and arg[1:].isdigit():
+            multiplier = int(arg[1:])
+        elif arg.isdigit():
+            multiplier = int(arg)
+    
+    # Calculate scroll amount
+    base_clicks = 25
+    clicks = base_clicks * multiplier
+    if direction == "down":
+        clicks = -clicks
+    
+    success = await asyncio.to_thread(scroll_screen, clicks)
+    
+    if success:
+        await update.message.reply_text(f"📜 Scrolled {direction} x{multiplier}")
+    else:
+        await update.message.reply_text("❌ Failed to scroll")
+
+
+async def accept_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    """Send Accept (Alt+Enter)."""
+    if not await is_authorized(update):
+        return
+    
+    await asyncio.to_thread(
+        lambda: (focus_antigravity(), time.sleep(0.2), pyautogui.hotkey('alt', 'enter'))
+    )
+    await update.message.reply_text("✅ Sent Accept (Alt+Enter)")
+
+
+async def reject_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    """Send Reject (Escape)."""
+    if not await is_authorized(update):
+        return
+    
+    await asyncio.to_thread(
+        lambda: (focus_antigravity(), time.sleep(0.2), pyautogui.press('escape'))
+    )
+    await update.message.reply_text("❌ Sent Reject (Escape)")
+
+
+async def undo_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    """Send Undo (Ctrl+Z)."""
+    if not await is_authorized(update):
+        return
+    
+    await asyncio.to_thread(
+        lambda: (focus_antigravity(), pyautogui.hotkey('ctrl', 'z'))
+    )
+    await update.message.reply_text("↩️ Sent Undo (Ctrl+Z)")

antigravity_remote/state.py

@@ -0,0 +1,76 @@
+"""State management for Antigravity Remote bot."""
+
+import asyncio
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Any, Optional
+
+
+@dataclass
+class CommandLogEntry:
+    """A single command log entry."""
+    timestamp: datetime
+    message: str
+    
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "time": self.timestamp.strftime("%H:%M:%S"),
+            "msg": self.message
+        }
+
+
+@dataclass
+class BotState:
+    """Mutable state for the Antigravity Remote bot."""
+    
+    # Control state
+    paused: bool = False
+    locked: bool = False
+    
+    # Background tasks
+    heartbeat_task: Optional[asyncio.Task] = None
+    watchdog_task: Optional[asyncio.Task] = None
+    
+    # Watchdog state
+    watchdog_last_alert: float = 0.0
+    watchdog_last_hash: Optional[int] = None
+    watchdog_idle_count: int = 0
+    
+    # Command history
+    command_log: list[CommandLogEntry] = field(default_factory=list)
+    max_log_entries: int = 100
+    
+    def log_command(self, message: str) -> None:
+        """Add a command to the log."""
+        self.command_log.append(
+            CommandLogEntry(timestamp=datetime.now(), message=message)
+        )
+        # Trim log if too long
+        if len(self.command_log) > self.max_log_entries:
+            self.command_log = self.command_log[-50:]
+    
+    def get_recent_logs(self, count: int = 10) -> list[CommandLogEntry]:
+        """Get the most recent log entries."""
+        return self.command_log[-count:]
+    
+    def cancel_tasks(self) -> None:
+        """Cancel all background tasks."""
+        if self.heartbeat_task:
+            self.heartbeat_task.cancel()
+            self.heartbeat_task = None
+        if self.watchdog_task:
+            self.watchdog_task.cancel()
+            self.watchdog_task = None
+    
+    def reset(self) -> None:
+        """Reset state to defaults."""
+        self.paused = False
+        self.locked = False
+        self.cancel_tasks()
+        self.watchdog_last_alert = 0.0
+        self.watchdog_last_hash = None
+        self.watchdog_idle_count = 0
+
+
+# Global state instance
+state = BotState()

antigravity_remote/utils/__init__.py

@@ -0,0 +1,16 @@
+"""Utility modules for Antigravity Remote."""
+
+from .automation import focus_antigravity, send_to_antigravity, send_key_combo, scroll_screen
+from .screenshot import take_screenshot, cleanup_screenshot
+from .ocr import scan_screen, detect_keywords
+
+__all__ = [
+    "focus_antigravity",
+    "send_to_antigravity", 
+    "send_key_combo",
+    "scroll_screen",
+    "take_screenshot",
+    "cleanup_screenshot",
+    "scan_screen",
+    "detect_keywords",
+]

antigravity_remote/utils/automation.py

@@ -0,0 +1,143 @@
+"""Window automation utilities for Antigravity Remote."""
+
+import logging
+import time
+from typing import Optional
+
+import pyautogui
+import pygetwindow as gw
+import pyperclip
+
+logger = logging.getLogger(__name__)
+
+# Configure pyautogui safety settings
+pyautogui.FAILSAFE = True
+pyautogui.PAUSE = 0.1
+
+
+def focus_antigravity() -> bool:
+    """
+    Focus the Antigravity/VS Code/Cursor window.
+    
+    Returns:
+        True if window was focused, False otherwise.
+    """
+    try:
+        # Try different window titles in priority order
+        window_titles = ['Antigravity IDE', 'Antigravity', 'Visual Studio Code', 'Cursor']
+        
+        for title in window_titles:
+            windows = gw.getWindowsWithTitle(title)
+            if windows:
+                win = windows[0]
+                if win.isMinimized:
+                    win.restore()
+                win.activate()
+                time.sleep(0.3)
+                return True
+                
+        logger.warning("No Antigravity/VS Code/Cursor window found")
+        return False
+        
+    except Exception as e:
+        logger.error(f"Error focusing window: {e}")
+        return False
+
+
+def send_to_antigravity(message: str) -> bool:
+    """
+    Send a message to the Antigravity chat input.
+    
+    Args:
+        message: The message to send.
+        
+    Returns:
+        True if message was sent, False otherwise.
+    """
+    try:
+        if not focus_antigravity():
+            return False
+        
+        time.sleep(0.3)
+        screen_width, screen_height = pyautogui.size()
+        
+        # Click in the chat input area (right side, near bottom)
+        chat_input_x = int(screen_width * 0.75)
+        chat_input_y = int(screen_height * 0.92)
+        
+        pyautogui.click(chat_input_x, chat_input_y)
+        time.sleep(0.3)
+        
+        # Select all and paste new message
+        pyautogui.hotkey('ctrl', 'a')
+        time.sleep(0.1)
+        
+        pyperclip.copy(message)
+        pyautogui.hotkey('ctrl', 'v')
+        time.sleep(0.2)
+        
+        # Send message
+        pyautogui.press('enter')
+        
+        logger.info(f"Sent message to Antigravity: {message[:50]}...")
+        return True
+        
+    except Exception as e:
+        logger.error(f"Error sending to Antigravity: {e}")
+        return False
+
+
+def send_key_combo(keys: list[str]) -> bool:
+    """
+    Send a keyboard shortcut.
+    
+    Args:
+        keys: List of keys to press together (e.g., ['ctrl', 's']).
+        
+    Returns:
+        True if keys were sent, False otherwise.
+    """
+    try:
+        if not focus_antigravity():
+            return False
+        
+        time.sleep(0.2)
+        pyautogui.hotkey(*keys)
+        logger.info(f"Sent key combo: {'+'.join(keys)}")
+        return True
+        
+    except Exception as e:
+        logger.error(f"Error sending key combo: {e}")
+        return False
+
+
+def scroll_screen(clicks: int, x_percent: float = 0.80, y_percent: float = 0.40) -> bool:
+    """
+    Scroll the screen at specified position.
+    
+    Args:
+        clicks: Number of scroll clicks (positive = up, negative = down).
+        x_percent: Horizontal position as percentage of screen width.
+        y_percent: Vertical position as percentage of screen height.
+        
+    Returns:
+        True if scroll was performed, False otherwise.
+    """
+    try:
+        if not focus_antigravity():
+            return False
+        
+        screen_width, screen_height = pyautogui.size()
+        x = int(screen_width * x_percent)
+        y = int(screen_height * y_percent)
+        
+        pyautogui.moveTo(x, y)
+        time.sleep(0.1)
+        pyautogui.scroll(clicks)
+        
+        logger.info(f"Scrolled {clicks} clicks at ({x}, {y})")
+        return True
+        
+    except Exception as e:
+        logger.error(f"Error scrolling: {e}")
+        return False