antigravity-remote 3.1.0__py3-none-any.whl

antigravity_remote/config.py

@@ -0,0 +1,73 @@
+"""Configuration management for Antigravity Remote."""
+
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional
+
+try:
+    from dotenv import load_dotenv
+    load_dotenv()
+except ImportError:
+    pass
+
+from .secrets import get_bot_token, get_user_id
+
+
+@dataclass
+class Config:
+    """Configuration for Antigravity Remote bot."""
+    
+    # Telegram settings - token is embedded, user ID from local config
+    bot_token: str = field(default_factory=get_bot_token)
+    allowed_user_id: str = field(default_factory=lambda: get_user_id() or "")
+    
+    # Workspace settings
+    workspace_path: Path = field(
+        default_factory=lambda: Path(os.getenv("WORKSPACE_PATH", os.getcwd()))
+    )
+    
+    # Security
+    lock_password: str = field(default_factory=lambda: os.getenv("LOCK_PASSWORD", "unlock123"))
+    
+    # OCR settings
+    tesseract_path: Optional[str] = field(
+        default_factory=lambda: os.getenv(
+            "TESSERACT_PATH", 
+            r"C:\Program Files\Tesseract-OCR\tesseract.exe"
+        )
+    )
+    
+    # Timing settings
+    watchdog_interval: int = field(
+        default_factory=lambda: int(os.getenv("WATCHDOG_INTERVAL", "5"))
+    )
+    alert_cooldown: int = field(
+        default_factory=lambda: int(os.getenv("ALERT_COOLDOWN", "30"))
+    )
+    
+    def validate(self) -> list[str]:
+        """Validate configuration and return list of errors."""
+        errors = []
+        
+        if not self.bot_token:
+            errors.append("Bot token not available")
+        if not self.allowed_user_id:
+            errors.append("User not registered. Run: antigravity-remote --register")
+        if not self.workspace_path.exists():
+            errors.append(f"WORKSPACE_PATH does not exist: {self.workspace_path}")
+            
+        return errors
+    
+    def reload_user_id(self) -> None:
+        """Reload user ID from local config."""
+        self.allowed_user_id = get_user_id() or ""
+    
+    @classmethod
+    def from_env(cls) -> "Config":
+        """Create configuration from environment variables."""
+        return cls()
+
+
+# Global config instance
+config = Config.from_env()

antigravity_remote/handlers/__init__.py

@@ -0,0 +1,77 @@
+"""Handler modules for Antigravity Remote."""
+
+from .control import (
+    start_command,
+    pause_command,
+    resume_command,
+    cancel_command,
+    key_command,
+    lock_command,
+    unlock_command,
+)
+from .screen import (
+    status_command,
+    scroll_command,
+    accept_command,
+    reject_command,
+    undo_command,
+)
+from .files import (
+    sysinfo_command,
+    files_command,
+    read_command,
+    diff_command,
+    log_command,
+)
+from .monitoring import (
+    heartbeat_command,
+    watchdog_command,
+    schedule_command,
+)
+from .ai import (
+    model_command,
+    summary_command,
+    handle_message,
+    handle_model_callback,
+)
+from .quick import (
+    quick_replies_command,
+    handle_quick_callback,
+    handle_voice,
+)
+
+__all__ = [
+    # 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",
+]

antigravity_remote/handlers/ai.py

@@ -0,0 +1,135 @@
+"""AI command handlers for Antigravity Remote."""
+
+import asyncio
+import logging
+import time
+
+import pyautogui
+import pyperclip
+
+from telegram import Update, InlineKeyboardButton, InlineKeyboardMarkup
+from telegram.ext import ContextTypes
+from telegram.constants import ParseMode
+
+from .base import is_authorized
+from ..state import state
+from ..utils import focus_antigravity, send_to_antigravity, take_screenshot, cleanup_screenshot
+
+logger = logging.getLogger(__name__)
+
+# Available models in Antigravity
+MODELS = [
+    ("Gemini 3 Pro (High)", "gemini_3_pro_high"),
+    ("Gemini 3 Pro (Low)", "gemini_3_pro_low"),
+    ("Gemini 3 Flash", "gemini_3_flash"),
+    ("Claude Sonnet 4.5", "claude_sonnet_45"),
+    ("Claude Sonnet 4.5 (Thinking)", "claude_sonnet_45_thinking"),
+    ("Claude Opus 4.5 (Thinking)", "claude_opus_45_thinking"),
+    ("GPT-OSS 120B (Medium)", "gpt_oss_120b"),
+]
+
+MODEL_NAMES = {model_id: name for name, model_id in MODELS}
+
+
+async def model_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    """Show model selection menu."""
+    if not await is_authorized(update):
+        return
+    
+    keyboard = [
+        [InlineKeyboardButton(name, callback_data=f"model_{model_id}")]
+        for name, model_id in MODELS
+    ]
+    
+    await update.message.reply_text(
+        "🤖 *Select a model:*\n\n_Note: Model availability depends on your subscription_",
+        reply_markup=InlineKeyboardMarkup(keyboard),
+        parse_mode=ParseMode.MARKDOWN
+    )
+
+
+async def summary_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    """Ask Antigravity for a task summary."""
+    if not await is_authorized(update):
+        return
+    
+    summary_prompt = "Please give me a brief summary of what you just did in the last task."
+    
+    status_msg = await update.message.reply_text("📝 Asking for summary...")
+    success = await asyncio.to_thread(send_to_antigravity, summary_prompt)
+    
+    if success:
+        keyboard = [[InlineKeyboardButton("📸 Get Summary", callback_data="screenshot")]]
+        await status_msg.edit_text(
+            "📝 *Summary requested!*\nWait a moment for the response, then tap:",
+            reply_markup=InlineKeyboardMarkup(keyboard),
+            parse_mode=ParseMode.MARKDOWN
+        )
+    else:
+        await status_msg.edit_text("❌ Failed to send summary request")
+
+
+async def handle_message(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    """Handle text messages - relay to Antigravity."""
+    if not await is_authorized(update):
+        return
+    
+    if state.locked:
+        await update.message.reply_text("🔒 Bot is locked. Use /unlock <password>")
+        return
+    
+    if state.paused:
+        await update.message.reply_text("⏸️ Relay is paused. Use /resume")
+        return
+    
+    user_msg = update.message.text
+    
+    # Log command
+    state.log_command(user_msg)
+    
+    status_msg = await update.message.reply_text("📤 Sending to Antigravity...")
+    success = await asyncio.to_thread(send_to_antigravity, user_msg)
+    
+    if not success:
+        await status_msg.edit_text("❌ Failed to send. Is Antigravity app open?")
+        return
+    
+    keyboard = [[InlineKeyboardButton("📸 Get Result", callback_data="screenshot")]]
+    await status_msg.edit_text(
+        "✅ *Sent!* Tap when ready:",
+        reply_markup=InlineKeyboardMarkup(keyboard),
+        parse_mode=ParseMode.MARKDOWN
+    )
+
+
+async def handle_model_callback(
+    query, 
+    context: ContextTypes.DEFAULT_TYPE,
+    model_id: str
+) -> None:
+    """Handle model selection callback."""
+    model_name = MODEL_NAMES.get(model_id, model_id)
+    
+    def switch_model():
+        focus_antigravity()
+        time.sleep(0.2)
+        # Open command palette
+        pyautogui.hotkey('ctrl', 'shift', 'p')
+        time.sleep(0.5)
+        # Type model switch command
+        pyperclip.copy("Switch Model")
+        pyautogui.hotkey('ctrl', 'v')
+        time.sleep(0.3)
+        pyautogui.press('enter')
+        time.sleep(0.3)
+        # Type model name
+        pyperclip.copy(model_name)
+        pyautogui.hotkey('ctrl', 'v')
+        time.sleep(0.2)
+        pyautogui.press('enter')
+    
+    await asyncio.to_thread(switch_model)
+    await query.message.reply_text(
+        f"🔄 Switching to *{model_name}*...",
+        parse_mode=ParseMode.MARKDOWN
+    )

antigravity_remote/handlers/base.py

@@ -0,0 +1,35 @@
+"""Base handler functionality for Antigravity Remote."""
+
+import logging
+from functools import wraps
+from typing import Callable, TypeVar, ParamSpec
+
+from telegram import Update
+from telegram.ext import ContextTypes
+
+from ..config import config
+
+logger = logging.getLogger(__name__)
+
+P = ParamSpec('P')
+T = TypeVar('T')
+
+
+def authorized_only(func: Callable[P, T]) -> Callable[P, T]:
+    """Decorator to require authorization for a handler."""
+    @wraps(func)
+    async def wrapper(update: Update, context: ContextTypes.DEFAULT_TYPE, *args, **kwargs):
+        user_id = str(update.effective_user.id)
+        
+        if user_id != config.allowed_user_id:
+            logger.warning(f"Unauthorized access attempt from user {user_id}")
+            return None
+        
+        return await func(update, context, *args, **kwargs)
+    
+    return wrapper
+
+
+async def is_authorized(update: Update) -> bool:
+    """Check if the update is from an authorized user."""
+    return str(update.effective_user.id) == config.allowed_user_id

antigravity_remote/handlers/control.py

@@ -0,0 +1,123 @@
+"""Control 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 ..state import state
+from ..utils import focus_antigravity, send_key_combo
+
+logger = logging.getLogger(__name__)
+
+
+async def start_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    """Show help menu."""
+    if not await is_authorized(update):
+        return
+    
+    help_text = """🔗 *Antigravity Remote Control*
+
+*Relay:* Send any message to relay it.
+
+*Commands:*
+`/status` - Screenshot now
+`/model` - Switch AI model
+`/quick` - Quick reply buttons
+`/summary` - Ask for task summary
+`/watchdog` - Smart auto-alerts
+`/pause` / `/resume` - Toggle relay
+`/cancel` - Send Escape
+`/scroll` - up/down/top/bottom
+`/accept` / `/reject` - Click buttons
+`/undo` - Ctrl+Z
+`/key` - Send key combo
+`/schedule` - Schedule command
+`/sysinfo` - System stats
+`/files` - List files
+`/read` - Read file
+`/diff` - Git diff
+`/log` - Command history
+`/lock` / `/unlock` - Security
+`/heartbeat` - Auto screenshots
+"""
+    await update.message.reply_text(help_text, parse_mode=ParseMode.MARKDOWN)
+
+
+async def pause_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    """Pause message relay."""
+    if not await is_authorized(update):
+        return
+    
+    state.paused = True
+    await update.message.reply_text("⏸️ Relay paused. Use /resume to continue.")
+
+
+async def resume_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    """Resume message relay."""
+    if not await is_authorized(update):
+        return
+    
+    state.paused = False
+    await update.message.reply_text("▶️ Relay resumed!")
+
+
+async def cancel_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    """Send Escape key."""
+    if not await is_authorized(update):
+        return
+    
+    await asyncio.to_thread(lambda: (focus_antigravity(), pyautogui.press('escape')))
+    await update.message.reply_text("❌ Sent Escape key")
+
+
+async def key_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    """Send a key combination."""
+    if not await is_authorized(update):
+        return
+    
+    args = context.args
+    if not args:
+        await update.message.reply_text("Usage: /key ctrl+s or /key alt+shift+tab")
+        return
+    
+    combo = args[0].lower().split('+')
+    success = await asyncio.to_thread(send_key_combo, combo)
+    
+    if success:
+        await update.message.reply_text(
+            f"⌨️ Sent: `{'+'.join(combo)}`",
+            parse_mode=ParseMode.MARKDOWN
+        )
+    else:
+        await update.message.reply_text("❌ Failed to send key combo")
+
+
+async def lock_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    """Lock the bot."""
+    if not await is_authorized(update):
+        return
+    
+    state.locked = True
+    await update.message.reply_text("🔒 Bot locked. Use /unlock <password> to unlock.")
+
+
+async def unlock_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    """Unlock the bot."""
+    if not await is_authorized(update):
+        return
+    
+    from ..config import config
+    
+    args = context.args
+    if args and args[0] == config.lock_password:
+        state.locked = False
+        await update.message.reply_text("🔓 Bot unlocked!")
+    else:
+        await update.message.reply_text("❌ Wrong password.")

antigravity_remote/handlers/files.py

@@ -0,0 +1,124 @@
+"""File command handlers for Antigravity Remote."""
+
+import logging
+import os
+import subprocess
+
+import psutil
+from telegram import Update
+from telegram.ext import ContextTypes
+from telegram.constants import ParseMode
+
+from .base import is_authorized
+from ..config import config
+
+logger = logging.getLogger(__name__)
+
+
+async def sysinfo_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    """Show system information."""
+    if not await is_authorized(update):
+        return
+    
+    cpu = psutil.cpu_percent(interval=1)
+    mem = psutil.virtual_memory()
+    disk = psutil.disk_usage('C:/')
+    
+    msg = f"""⚙️ *System Info*
+CPU: `{cpu}%`
+RAM: `{mem.percent}%` ({mem.used // (1024**3)}GB / {mem.total // (1024**3)}GB)
+Disk C: `{disk.percent}%` ({disk.used // (1024**3)}GB / {disk.total // (1024**3)}GB)
+"""
+    await update.message.reply_text(msg, parse_mode=ParseMode.MARKDOWN)
+
+
+async def files_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    """List files in workspace."""
+    if not await is_authorized(update):
+        return
+    
+    try:
+        items = os.listdir(config.workspace_path)
+        files = []
+        for item in items[:30]:
+            path = config.workspace_path / item
+            icon = "📄" if path.is_file() else "📁"
+            files.append(f"{icon} {item}")
+        
+        await update.message.reply_text(
+            f"📂 *Files in workspace:*\n" + "\n".join(files),
+            parse_mode=ParseMode.MARKDOWN
+        )
+    except Exception as e:
+        await update.message.reply_text(f"Error: {e}")
+
+
+async def read_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    """Read a file's contents."""
+    if not await is_authorized(update):
+        return
+    
+    args = context.args
+    if not args:
+        await update.message.reply_text("Usage: /read filename.txt")
+        return
+    
+    filepath = config.workspace_path / args[0]
+    
+    try:
+        with open(filepath, 'r', encoding='utf-8') as f:
+            content = f.read()[:3000]
+        
+        await update.message.reply_text(
+            f"📄 *{args[0]}*:\n```\n{content}\n```",
+            parse_mode=ParseMode.MARKDOWN
+        )
+    except Exception as e:
+        await update.message.reply_text(f"Error reading file: {e}")
+
+
+async def diff_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    """Show git diff."""
+    if not await is_authorized(update):
+        return
+    
+    try:
+        result = subprocess.run(
+            ['git', 'diff', '--stat'],
+            cwd=config.workspace_path,
+            capture_output=True,
+            text=True,
+            timeout=10
+        )
+        output = result.stdout[:3000] or "No changes"
+        
+        await update.message.reply_text(
+            f"📊 *Git Diff:*\n```\n{output}\n```",
+            parse_mode=ParseMode.MARKDOWN
+        )
+    except Exception as e:
+        await update.message.reply_text(f"Error: {e}")
+
+
+async def log_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    """Show command history."""
+    if not await is_authorized(update):
+        return
+    
+    from ..state import state
+    
+    logs = state.get_recent_logs(10)
+    
+    if not logs:
+        await update.message.reply_text("📋 No commands logged yet.")
+        return
+    
+    log_text = "\n".join([
+        f"`{entry.to_dict()['time']}`: {entry.message[:50]}"
+        for entry in logs
+    ])
+    
+    await update.message.reply_text(
+        f"📋 *Recent Commands:*\n{log_text}",
+        parse_mode=ParseMode.MARKDOWN
+    )