voidremote 1.0.0__py3-none-any.whl

voidremote/config/__init__.py

@@ -0,0 +1,37 @@
+"""VoidRemote configuration management."""
+
+from voidremote.config.settings import (
+    AdbSettings,
+    AppSettings,
+    CACHE_DIR,
+    CONFIG_DIR,
+    CONFIG_FILE,
+    DATA_DIR,
+    LOG_DIR,
+    LOG_FILE,
+    LoggingSettings,
+    MirrorSettings,
+    TRUSTED_DEVICES_FILE,
+    UISettings,
+    ensure_dirs,
+    get_settings,
+    save_settings,
+)
+
+__all__ = [
+    "AdbSettings",
+    "AppSettings",
+    "CACHE_DIR",
+    "CONFIG_DIR",
+    "CONFIG_FILE",
+    "DATA_DIR",
+    "LOG_DIR",
+    "LOG_FILE",
+    "LoggingSettings",
+    "MirrorSettings",
+    "TRUSTED_DEVICES_FILE",
+    "UISettings",
+    "ensure_dirs",
+    "get_settings",
+    "save_settings",
+]

voidremote/config/settings.py

@@ -0,0 +1,203 @@
+"""
+Application settings and configuration management.
+
+Uses pydantic-settings for type-safe, validated configuration with
+environment variable support and JSON persistence.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from pathlib import Path
+from typing import Any, Optional
+
+import appdirs
+from pydantic import Field, field_validator
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+logger = logging.getLogger(__name__)
+
+APP_NAME = "VoidRemote"
+APP_AUTHOR = "V0IDNETWORK"
+
+# Platform-aware config directory
+CONFIG_DIR = Path(appdirs.user_config_dir(APP_NAME, APP_AUTHOR))
+DATA_DIR = Path(appdirs.user_data_dir(APP_NAME, APP_AUTHOR))
+LOG_DIR = Path(appdirs.user_log_dir(APP_NAME, APP_AUTHOR))
+CACHE_DIR = Path(appdirs.user_cache_dir(APP_NAME, APP_AUTHOR))
+
+CONFIG_FILE = CONFIG_DIR / "settings.json"
+TRUSTED_DEVICES_FILE = DATA_DIR / "trusted_devices.json"
+LOG_FILE = LOG_DIR / "voidremote.log"
+
+
+class AdbSettings(BaseSettings):
+    """ADB-specific configuration."""
+
+    model_config = SettingsConfigDict(env_prefix="VOIDREMOTE_ADB_")
+
+    path: str = Field(default="adb", description="Path to the ADB binary")
+    default_port: int = Field(default=5555, ge=1, le=65535)
+    connection_timeout: float = Field(default=10.0, gt=0)
+    command_timeout: float = Field(default=30.0, gt=0)
+    retry_count: int = Field(default=3, ge=0)
+    retry_delay: float = Field(default=1.0, ge=0)
+    server_port: int = Field(default=5037, ge=1, le=65535)
+    auto_start_server: bool = Field(default=True)
+    kill_server_on_exit: bool = Field(default=False)
+
+    @field_validator("path")
+    @classmethod
+    def validate_adb_path(cls, v: str) -> str:
+        """Validate that adb path is non-empty."""
+        if not v.strip():
+            return "adb"
+        return v.strip()
+
+
+class UISettings(BaseSettings):
+    """UI / appearance configuration."""
+
+    model_config = SettingsConfigDict(env_prefix="VOIDREMOTE_UI_")
+
+    theme: str = Field(default="dark", pattern="^(dark|light|auto)$")
+    language: str = Field(default="en")
+    font_family: str = Field(default="Inter")
+    font_size: int = Field(default=13, ge=8, le=24)
+    window_width: int = Field(default=1280, ge=800)
+    window_height: int = Field(default=800, ge=600)
+    window_maximized: bool = Field(default=False)
+    sidebar_width: int = Field(default=220, ge=160, le=400)
+    show_statusbar: bool = Field(default=True)
+    show_toolbar: bool = Field(default=True)
+    animations_enabled: bool = Field(default=True)
+    notifications_enabled: bool = Field(default=True)
+    tray_icon_enabled: bool = Field(default=True)
+
+
+class MirrorSettings(BaseSettings):
+    """Screen mirroring configuration."""
+
+    model_config = SettingsConfigDict(env_prefix="VOIDREMOTE_MIRROR_")
+
+    max_fps: int = Field(default=30, ge=1, le=120)
+    max_bitrate_mbps: int = Field(default=8, ge=1, le=64)
+    max_width: int = Field(default=1920, ge=320)
+    max_height: int = Field(default=1080, ge=240)
+    encoder: str = Field(default="h264")
+    orientation_lock: bool = Field(default=False)
+    show_touches: bool = Field(default=False)
+    stay_awake: bool = Field(default=True)
+    turn_screen_off: bool = Field(default=False)
+    always_on_top: bool = Field(default=False)
+    fullscreen: bool = Field(default=False)
+    record_path: Optional[str] = Field(default=None)
+
+
+class LoggingSettings(BaseSettings):
+    """Logging configuration."""
+
+    model_config = SettingsConfigDict(env_prefix="VOIDREMOTE_LOG_")
+
+    level: str = Field(default="INFO", pattern="^(DEBUG|INFO|WARNING|ERROR|CRITICAL)$")
+    file_enabled: bool = Field(default=True)
+    file_path: Optional[str] = Field(default=None)
+    max_file_size_mb: int = Field(default=10, ge=1, le=100)
+    backup_count: int = Field(default=5, ge=0, le=20)
+    format: str = Field(
+        default="%(asctime)s | %(levelname)-8s | %(name)-30s | %(message)s"
+    )
+    console_enabled: bool = Field(default=True)
+    console_color: bool = Field(default=True)
+
+
+class KeyboardShortcuts(BaseSettings):
+    """Keyboard shortcut bindings."""
+
+    model_config = SettingsConfigDict(env_prefix="VOIDREMOTE_KEY_")
+
+    connect_device: str = Field(default="Ctrl+Shift+C")
+    disconnect_device: str = Field(default="Ctrl+Shift+D")
+    screenshot: str = Field(default="Ctrl+Shift+S")
+    start_mirror: str = Field(default="Ctrl+Shift+M")
+    open_shell: str = Field(default="Ctrl+Shift+T")
+    open_files: str = Field(default="Ctrl+Shift+F")
+    refresh_devices: str = Field(default="F5")
+    toggle_fullscreen: str = Field(default="F11")
+    quit: str = Field(default="Ctrl+Q")
+
+
+class AppSettings(BaseSettings):
+    """Root application settings."""
+
+    model_config = SettingsConfigDict(
+        env_prefix="VOIDREMOTE_",
+        env_nested_delimiter="__",
+    )
+
+    app_name: str = Field(default="VoidRemote")
+    version: str = Field(default="1.0.0")
+    debug: bool = Field(default=False)
+    first_run: bool = Field(default=True)
+    check_updates: bool = Field(default=True)
+    update_channel: str = Field(default="stable", pattern="^(stable|beta|nightly)$")
+    telemetry_enabled: bool = Field(default=False)
+
+    adb: AdbSettings = Field(default_factory=AdbSettings)
+    ui: UISettings = Field(default_factory=UISettings)
+    mirror: MirrorSettings = Field(default_factory=MirrorSettings)
+    logging: LoggingSettings = Field(default_factory=LoggingSettings)
+    shortcuts: KeyboardShortcuts = Field(default_factory=KeyboardShortcuts)
+
+    def save(self, path: Optional[Path] = None) -> None:
+        """Persist settings to JSON file."""
+        target = path or CONFIG_FILE
+        target.parent.mkdir(parents=True, exist_ok=True)
+        with open(target, "w", encoding="utf-8") as fh:
+            fh.write(self.model_dump_json(indent=2))
+        logger.debug("Settings saved to %s", target)
+
+    @classmethod
+    def load(cls, path: Optional[Path] = None) -> "AppSettings":
+        """Load settings from JSON file, falling back to defaults."""
+        target = path or CONFIG_FILE
+        if target.exists():
+            try:
+                data: dict[str, Any] = json.loads(target.read_text(encoding="utf-8"))
+                instance = cls(**data)
+                logger.debug("Settings loaded from %s", target)
+                return instance
+            except Exception as exc:
+                logger.warning("Failed to load settings from %s: %s", target, exc)
+        return cls()
+
+    def reset_to_defaults(self) -> None:
+        """Reset all settings to defaults."""
+        defaults = AppSettings()
+        for key, value in defaults.model_dump().items():
+            setattr(self, key, value)
+
+
+# Singleton instance - loaded lazily
+_settings_instance: Optional[AppSettings] = None
+
+
+def get_settings() -> AppSettings:
+    """Return the global settings singleton."""
+    global _settings_instance
+    if _settings_instance is None:
+        _settings_instance = AppSettings.load()
+    return _settings_instance
+
+
+def save_settings() -> None:
+    """Save the global settings singleton."""
+    settings = get_settings()
+    settings.save()
+
+
+def ensure_dirs() -> None:
+    """Ensure all application directories exist."""
+    for directory in (CONFIG_DIR, DATA_DIR, LOG_DIR, CACHE_DIR):
+        directory.mkdir(parents=True, exist_ok=True)

voidremote/controllers/__init__.py

@@ -0,0 +1,5 @@
+"""VoidRemote application controllers."""
+
+from voidremote.controllers.app_controller import AppController
+
+__all__ = ["AppController"]

voidremote/controllers/app_controller.py

@@ -0,0 +1,222 @@
+"""
+Application controller - dependency injection root.
+
+Owns all service instances and provides a unified facade used by
+both the CLI and the GUI. This prevents duplication and ensures
+a single ADB client is shared across the application.
+"""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+from typing import Optional
+
+from voidremote.adb.client import AdbClient, AdbNotFoundError
+from voidremote.config.settings import AppSettings, get_settings
+from voidremote.models.device import Device, PairingInfo
+from voidremote.services.device_service import DeviceService
+from voidremote.services.input_service import InputService, KeyCode
+from voidremote.services.monitor_service import MonitorService, SnapshotCallback
+
+logger = logging.getLogger(__name__)
+
+
+class AppController:
+    """
+    Central application controller.
+
+    Instantiate once at startup, then pass to CLI commands or the GUI.
+
+    Example::
+
+        ctrl = AppController()
+        ctrl.initialize()
+        devices = ctrl.list_devices()
+    """
+
+    def __init__(self, settings: Optional[AppSettings] = None) -> None:
+        self._settings = settings or get_settings()
+        self._adb = AdbClient(
+            adb_path=self._settings.adb.path,
+            default_timeout=self._settings.adb.command_timeout,
+            server_port=self._settings.adb.server_port,
+        )
+        self._device_service = DeviceService(self._adb)
+        self._input_service = InputService(self._adb)
+        self._monitor_service = MonitorService(self._adb)
+        self._initialized = False
+
+    # ------------------------------------------------------------------
+    # Lifecycle
+    # ------------------------------------------------------------------
+
+    def initialize(self) -> str:
+        """
+        Initialize the controller — verify ADB, optionally start server.
+
+        Returns:
+            ADB version string.
+
+        Raises:
+            AdbNotFoundError: If ADB binary is not available.
+        """
+        version = self._adb.verify_adb()
+        if self._settings.adb.auto_start_server:
+            try:
+                self._adb.start_server()
+            except Exception as exc:
+                logger.warning("Failed to start ADB server: %s", exc)
+        self._initialized = True
+        logger.info("AppController initialized, ADB: %s", version)
+        return version
+
+    def shutdown(self) -> None:
+        """Graceful shutdown — stop monitors, optionally kill ADB."""
+        self._monitor_service.stop_all()
+        if self._settings.adb.kill_server_on_exit:
+            try:
+                self._adb.kill_server()
+            except Exception as exc:
+                logger.warning("Failed to kill ADB server on exit: %s", exc)
+        logger.info("AppController shut down")
+
+    # ------------------------------------------------------------------
+    # Device management
+    # ------------------------------------------------------------------
+
+    def list_devices(self, refresh: bool = True) -> list[Device]:
+        """List connected devices, optionally refreshing first."""
+        if refresh:
+            return self._device_service.refresh_devices()
+        return self._device_service.list_devices()
+
+    def get_device(self, serial: str) -> Optional[Device]:
+        """Get a specific device by serial."""
+        return self._device_service.get_device(serial)
+
+    def pair_device(self, host: str, port: int, code: str) -> bool:
+        """Pair via wireless debugging."""
+        return self._device_service.pair_device(host, port, code)
+
+    def connect_device(
+        self, host: str, port: int = 5555, remember: bool = True
+    ) -> Device:
+        """Connect to a wireless device."""
+        return self._device_service.connect_device(host, port, remember)
+
+    def disconnect_device(self, serial: str) -> bool:
+        """Disconnect a wireless device."""
+        return self._device_service.disconnect_device(serial)
+
+    def auto_reconnect(self) -> list[Device]:
+        """Reconnect all trusted auto-connect devices."""
+        return self._device_service.auto_reconnect_trusted()
+
+    # ------------------------------------------------------------------
+    # Input
+    # ------------------------------------------------------------------
+
+    def tap(self, serial: str, x: int, y: int) -> None:
+        self._input_service.tap(serial, x, y)
+
+    def swipe(
+        self,
+        serial: str,
+        x1: int,
+        y1: int,
+        x2: int,
+        y2: int,
+        duration_ms: int = 300,
+    ) -> None:
+        self._input_service.swipe(serial, x1, y1, x2, y2, duration_ms)
+
+    def type_text(self, serial: str, text: str) -> None:
+        self._input_service.type_text(serial, text)
+
+    def key_event(self, serial: str, keycode: int) -> None:
+        self._input_service.key_event(serial, keycode)
+
+    # ------------------------------------------------------------------
+    # File operations
+    # ------------------------------------------------------------------
+
+    def push_file(self, serial: str, local: Path, remote: str) -> None:
+        """Push a local file to the device."""
+        self._adb.push(serial, local, remote)
+
+    def pull_file(self, serial: str, remote: str, local: Path) -> None:
+        """Pull a file from the device."""
+        self._adb.pull(serial, remote, local)
+
+    # ------------------------------------------------------------------
+    # APK management
+    # ------------------------------------------------------------------
+
+    def install_apk(self, serial: str, apk_path: Path, replace: bool = True) -> None:
+        """Install an APK."""
+        self._adb.install(serial, apk_path, replace=replace)
+
+    def uninstall_app(self, serial: str, package: str) -> None:
+        """Uninstall an app package."""
+        self._adb.uninstall(serial, package)
+
+    # ------------------------------------------------------------------
+    # Screenshot & recording
+    # ------------------------------------------------------------------
+
+    def take_screenshot(self, serial: str, output: Path) -> Path:
+        """Capture a screenshot and save to output path."""
+        output.parent.mkdir(parents=True, exist_ok=True)
+        self._adb.screenshot(serial, output)
+        return output
+
+    def start_screen_record(
+        self, serial: str, remote_path: str = "/sdcard/void_rec.mp4"
+    ) -> "subprocess.Popen[bytes]":  # noqa: F821
+        return self._adb.screenrecord(serial, remote_path)
+
+    # ------------------------------------------------------------------
+    # Shell
+    # ------------------------------------------------------------------
+
+    def shell(self, serial: str, command: str) -> str:
+        """Run an ADB shell command, return stdout."""
+        return self._adb.shell(serial, command).stdout
+
+    # ------------------------------------------------------------------
+    # Reboot
+    # ------------------------------------------------------------------
+
+    def reboot(self, serial: str, mode: str = "") -> None:
+        """Reboot device."""
+        self._adb.reboot(serial, mode)
+
+    # ------------------------------------------------------------------
+    # Monitoring
+    # ------------------------------------------------------------------
+
+    def start_monitoring(
+        self,
+        serial: str,
+        interval: float = 2.0,
+        callback: Optional[SnapshotCallback] = None,
+    ) -> None:
+        """Start real-time monitoring for a device."""
+        self._monitor_service.start(serial, interval, callback)
+
+    def stop_monitoring(self, serial: str) -> None:
+        """Stop monitoring a device."""
+        self._monitor_service.stop(serial)
+
+    # ------------------------------------------------------------------
+    # Properties
+    # ------------------------------------------------------------------
+
+    @property
+    def settings(self) -> AppSettings:
+        return self._settings
+
+    @property
+    def is_initialized(self) -> bool:
+        return self._initialized

voidremote/core/__init__.py

@@ -0,0 +1 @@
+"""VoidRemote core package."""

voidremote/core/automation.py

@@ -0,0 +1,184 @@
+"""
+Automation engine — macro recording and playback.
+
+Records sequences of input events and replays them on demand.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import time
+from dataclasses import asdict, dataclass, field
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class MacroStep:
+    """A single recorded automation step."""
+
+    action: str           # tap | swipe | text | keyevent | sleep
+    params: dict          # action-specific parameters
+    delay_after: float = 0.0  # seconds to wait after this step
+
+
+@dataclass
+class Macro:
+    """A recorded sequence of automation steps."""
+
+    name: str
+    steps: list[MacroStep] = field(default_factory=list)
+    created_at: str = field(default_factory=lambda: datetime.now().isoformat())
+    description: str = ""
+    repeat: int = 1
+
+    def to_dict(self) -> dict:
+        return {
+            "name": self.name,
+            "description": self.description,
+            "created_at": self.created_at,
+            "repeat": self.repeat,
+            "steps": [asdict(s) for s in self.steps],
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "Macro":
+        steps = [MacroStep(**s) for s in data.get("steps", [])]
+        return cls(
+            name=data["name"],
+            description=data.get("description", ""),
+            created_at=data.get("created_at", ""),
+            repeat=data.get("repeat", 1),
+            steps=steps,
+        )
+
+
+class MacroRecorder:
+    """Records user input actions into a Macro."""
+
+    def __init__(self, name: str) -> None:
+        self._name = name
+        self._steps: list[MacroStep] = []
+        self._last_time: float = time.monotonic()
+
+    def _delay(self) -> float:
+        now = time.monotonic()
+        delay = now - self._last_time
+        self._last_time = now
+        return round(delay, 3)
+
+    def record_tap(self, x: int, y: int) -> None:
+        self._steps.append(MacroStep("tap", {"x": x, "y": y}, self._delay()))
+
+    def record_swipe(self, x1: int, y1: int, x2: int, y2: int, duration_ms: int = 300) -> None:
+        self._steps.append(MacroStep(
+            "swipe", {"x1": x1, "y1": y1, "x2": x2, "y2": y2, "duration_ms": duration_ms},
+            self._delay()
+        ))
+
+    def record_text(self, text: str) -> None:
+        self._steps.append(MacroStep("text", {"text": text}, self._delay()))
+
+    def record_keyevent(self, keycode: int) -> None:
+        self._steps.append(MacroStep("keyevent", {"keycode": keycode}, self._delay()))
+
+    def record_sleep(self, seconds: float) -> None:
+        self._steps.append(MacroStep("sleep", {"seconds": seconds}, 0.0))
+
+    def finish(self) -> Macro:
+        return Macro(name=self._name, steps=self._steps)
+
+
+class MacroPlayer:
+    """Plays back a Macro on a target device."""
+
+    def __init__(self, controller: object) -> None:
+        self._controller = controller
+        self._running = False
+
+    def play(self, macro: Macro, serial: str, speed: float = 1.0) -> None:
+        """
+        Execute a macro on the specified device.
+
+        Args:
+            macro: The macro to play.
+            serial: ADB device serial.
+            speed: Playback speed multiplier (1.0 = recorded speed).
+        """
+        self._running = True
+        logger.info("Playing macro '%s' on %s (repeat=%d)", macro.name, serial, macro.repeat)
+
+        for iteration in range(macro.repeat):
+            if not self._running:
+                break
+            logger.debug("Macro iteration %d/%d", iteration + 1, macro.repeat)
+            for step in macro.steps:
+                if not self._running:
+                    break
+                if step.delay_after > 0:
+                    time.sleep(step.delay_after / speed)
+                self._execute_step(step, serial)
+
+        self._running = False
+        logger.info("Macro '%s' completed", macro.name)
+
+    def stop(self) -> None:
+        self._running = False
+
+    def _execute_step(self, step: MacroStep, serial: str) -> None:
+        try:
+            if step.action == "tap":
+                self._controller.tap(serial, step.params["x"], step.params["y"])
+            elif step.action == "swipe":
+                self._controller.swipe(
+                    serial,
+                    step.params["x1"], step.params["y1"],
+                    step.params["x2"], step.params["y2"],
+                    step.params.get("duration_ms", 300),
+                )
+            elif step.action == "text":
+                self._controller.type_text(serial, step.params["text"])
+            elif step.action == "keyevent":
+                self._controller.key_event(serial, step.params["keycode"])
+            elif step.action == "sleep":
+                time.sleep(step.params.get("seconds", 0.5))
+        except Exception as exc:
+            logger.warning("Macro step '%s' failed: %s", step.action, exc)
+
+
+class MacroLibrary:
+    """Persistent storage for saved macros."""
+
+    def __init__(self, storage_dir: Path) -> None:
+        self._dir = storage_dir
+        self._dir.mkdir(parents=True, exist_ok=True)
+
+    def save(self, macro: Macro) -> Path:
+        safe_name = macro.name.replace(" ", "_").replace("/", "_")
+        path = self._dir / f"{safe_name}.json"
+        path.write_text(json.dumps(macro.to_dict(), indent=2), encoding="utf-8")
+        logger.debug("Saved macro: %s", path)
+        return path
+
+    def load(self, name: str) -> Macro:
+        safe_name = name.replace(" ", "_").replace("/", "_")
+        path = self._dir / f"{safe_name}.json"
+        if not path.exists():
+            raise FileNotFoundError(f"Macro not found: {name!r}")
+        data = json.loads(path.read_text(encoding="utf-8"))
+        return Macro.from_dict(data)
+
+    def list_macros(self) -> list[str]:
+        return [p.stem.replace("_", " ") for p in self._dir.glob("*.json")]
+
+    def delete(self, name: str) -> bool:
+        safe_name = name.replace(" ", "_").replace("/", "_")
+        path = self._dir / f"{safe_name}.json"
+        if path.exists():
+            path.unlink()
+            return True
+        return False

voidremote/models/__init__.py

@@ -0,0 +1,31 @@
+"""VoidRemote data models."""
+
+from voidremote.models.device import (
+    BatteryInfo,
+    ConnectionConfig,
+    ConnectionType,
+    CpuInfo,
+    Device,
+    DeviceCapability,
+    DeviceInfo,
+    DeviceState,
+    NetworkInfo,
+    PairingInfo,
+    StorageInfo,
+    TrustedDevice,
+)
+
+__all__ = [
+    "BatteryInfo",
+    "ConnectionConfig",
+    "ConnectionType",
+    "CpuInfo",
+    "Device",
+    "DeviceCapability",
+    "DeviceInfo",
+    "DeviceState",
+    "NetworkInfo",
+    "PairingInfo",
+    "StorageInfo",
+    "TrustedDevice",
+]