apkdev 2.0.0__py3-none-any.whl

apkdev/sdk.py

@@ -0,0 +1,526 @@
+"""SDK manager — cross-platform setup and tool checking."""
+
+import os
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+
+from .utils import ANDROID_HOME, ensure_android_home
+
+console = Console()
+
+
+def detect_platform() -> dict:
+    """Detect platform and return package manager info."""
+    info = {
+        "system": sys.platform,
+        "is_termux": "TERMUX_VERSION" in os.environ,
+        "is_android": os.environ.get("ANDROID_ROOT") == "/system",
+        "pkg_manager": None,
+        "pkg_install_cmd": None,
+        "pkg_update_cmd": None,
+        "java_pkg": "java",
+        "home_dir": str(Path.home()),
+    }
+
+    if info["is_termux"]:
+        info["pkg_manager"] = "pkg"
+        info["pkg_install_cmd"] = ["pkg", "install", "-y"]
+        info["pkg_update_cmd"] = ["pkg", "update"]
+        info["java_pkg"] = "openjdk-21"
+        info["platform_name"] = "Termux (Android)"
+    elif sys.platform == "linux":
+        if shutil.which("apt-get"):
+            info["pkg_manager"] = "apt"
+            info["pkg_install_cmd"] = ["sudo", "apt-get", "install", "-y"]
+            info["pkg_update_cmd"] = ["sudo", "apt-get", "update"]
+            info["java_pkg"] = "openjdk-21-jdk"
+            info["platform_name"] = "Linux (Debian/Ubuntu)"
+        elif shutil.which("dnf"):
+            info["pkg_manager"] = "dnf"
+            info["pkg_install_cmd"] = ["sudo", "dnf", "install", "-y"]
+            info["java_pkg"] = "java-21-openjdk-devel"
+            info["platform_name"] = "Linux (Fedora/RHEL)"
+        elif shutil.which("pacman"):
+            info["pkg_manager"] = "pacman"
+            info["pkg_install_cmd"] = ["sudo", "pacman", "-S", "--noconfirm"]
+            info["java_pkg"] = "jdk21-openjdk"
+            info["platform_name"] = "Linux (Arch)"
+        else:
+            info["platform_name"] = "Linux (unknown package manager)"
+    elif sys.platform == "darwin":
+        if shutil.which("brew"):
+            info["pkg_manager"] = "brew"
+            info["pkg_install_cmd"] = ["brew", "install"]
+            info["java_pkg"] = "openjdk@21"
+            info["platform_name"] = "macOS (Homebrew)"
+        else:
+            info["platform_name"] = "macOS (no Homebrew)"
+    elif sys.platform == "win32":
+        if shutil.which("winget"):
+            info["pkg_manager"] = "winget"
+            info["pkg_install_cmd"] = ["winget", "install"]
+            info["java_pkg"] = "Amazon.Corretto.21"
+            info["platform_name"] = "Windows (winget)"
+        elif shutil.which("choco"):
+            info["pkg_manager"] = "choco"
+            info["pkg_install_cmd"] = ["choco", "install", "-y"]
+            info["java_pkg"] = "openjdk21"
+            info["platform_name"] = "Windows (Chocolatey)"
+        else:
+            info["platform_name"] = "Windows"
+    else:
+        info["platform_name"] = sys.platform
+
+    return info
+
+
+def _version_or_none(cmd: str, *args: str) -> str:
+    """Get version string from a tool."""
+    tool = shutil.which(cmd)
+    if not tool:
+        return "❌ Not found"
+    try:
+        r = subprocess.run([tool] + list(args), capture_output=True, text=True, timeout=5)
+        out = r.stdout.split("\n")[0].strip()
+        return out[:80] if out else "✅ OK"
+    except Exception:
+        return "✅ OK"
+
+
+def info() -> None:
+    """Display environment info with platform detection."""
+    ensure_android_home()
+    plat = detect_platform()
+
+    console.print(f"[bold cyan]📱 APKDev — {plat['platform_name']}[/]")
+    console.print()
+
+    # Build tools table
+    table = Table(title="Build Tools", border_style="blue")
+    table.add_column("Tool", style="bold yellow")
+    table.add_column("Status", style="green")
+
+    table.add_row("Java", _version_or_none("java", "-version"))
+    table.add_row("Kotlin", _version_or_none("kotlin", "-version"))
+    table.add_row("Gradle", _version_or_none("gradle", "--version"))
+    table.add_row("AAPT2", _version_or_none("aapt2", "version"))
+    table.add_row("D8", _version_or_none("d8", "--version"))
+    table.add_row("ADB", _version_or_none("adb", "--version"))
+    table.add_row("Apksigner", _version_or_none("apksigner", "version"))
+    table.add_row("Zipalign", "✅ OK" if shutil.which("zipalign") else "❌ Not found")
+
+    sdk = "❌ Not found"
+    platforms_dir = Path(ANDROID_HOME) / "platforms"
+    if platforms_dir.exists():
+        plats = [p.name for p in platforms_dir.iterdir() if p.is_dir()]
+        sdk = ", ".join(plats) if plats else "❌ No platforms"
+    table.add_row("Android SDK", sdk)
+
+    console.print(table)
+    console.print()
+
+    # RE tools table
+    table2 = Table(title="Reverse Engineering Tools", border_style="magenta")
+    table2.add_column("Tool", style="bold yellow")
+    table2.add_column("Status", style="green")
+
+    table2.add_row("Apktool", _version_or_none("apktool", "--version"))
+    table2.add_row("jadx", _version_or_none("jadx", "--version"))
+
+    smali_sh = shutil.which("smali")
+    baksmali_sh = shutil.which("baksmali")
+    table2.add_row("smali", f"✅ {smali_sh}" if smali_sh else "❌ Not found")
+    table2.add_row("baksmali", f"✅ {baksmali_sh}" if baksmali_sh else "❌ Not found")
+    table2.add_row("dex2jar", "✅ OK" if shutil.which("d2j-dex2jar") else "❌ Not found")
+
+    aej = Path.home() / ".APKEditor.jar"
+    if aej.exists():
+        try:
+            r = subprocess.run(["java", "-jar", str(aej), "--version"],
+                              capture_output=True, text=True, timeout=5)
+            table2.add_row("APKEditor", r.stdout.strip() or "✅ OK")
+        except Exception:
+            table2.add_row("APKEditor", "✅ OK")
+    else:
+        table2.add_row("APKEditor", "❌ Not found")
+
+    try:
+        __import__("androguard")
+        table2.add_row("androguard", "✅ OK")
+    except ImportError:
+        table2.add_row("androguard", "❌ Not found")
+
+    console.print(table2)
+    console.print(f"\n[dim]Platform: {plat['platform_name']} | Python: {sys.version.split()[0]}[/]")
+
+
+def _download_jar(url: str, dest: Path) -> bool:
+    """Download a JAR file using pure Python urllib."""
+    import urllib.request
+    try:
+        urllib.request.urlretrieve(url, str(dest))
+        return dest.exists() and dest.stat().st_size > 1000
+    except Exception:
+        return False
+
+
+def _create_wrapper(path: Path, name: str) -> None:
+    """Create a wrapper script (platform-aware)."""
+    import stat
+    path.parent.mkdir(parents=True, exist_ok=True)
+    if sys.platform == "win32":
+        path = path.with_suffix(".bat")
+        content = f"@echo off\njava -jar \"%USERPROFILE%\\.{name}.jar\" %*\n"
+    else:
+        content = f"#!/usr/bin/env bash\nexec java -jar \"$HOME/.{name}.jar\" \"$@\"\n"
+    path.write_text(content)
+    if sys.platform != "win32":
+        path.chmod(0o755 | stat.S_IRUSR | stat.S_IXUSR | stat.S_IRGRP | stat.S_IXGRP | stat.S_IROTH | stat.S_IXOTH)
+
+
+def _install_java(plat: dict) -> bool:
+    """Try to install Java via package manager.
+    Returns True if Java was installed or already present."""
+    if shutil.which("java"):
+        return True
+    
+    console.print()
+    console.print("[bold]📌 Java is required. Attempting to install...[/]")
+    
+    try:
+        if plat["is_termux"]:
+            # Termux — no root needed
+            console.print(f"   Running: pkg install {plat['java_pkg']}")
+            r = subprocess.run(["pkg", "install", "-y", plat["java_pkg"]],
+                             capture_output=True, text=True, timeout=120)
+            if r.returncode == 0:
+                console.print("   ✅ Java installed via pkg")
+                return shutil.which("java") is not None
+            else:
+                console.print(f"   ⚠️  Failed: {r.stderr[-200:]}")
+                return False
+                
+        elif sys.platform == "linux":
+            # Linux — try sudo apt/dnf/pacman
+            pm = plat["pkg_install_cmd"]
+            if pm:
+                console.print(f"   Running: {' '.join(pm)} {plat['java_pkg']}")
+                console.print("   [yellow](you may be prompted for sudo password)[/]")
+                r = subprocess.run(pm + [plat["java_pkg"]],
+                                 capture_output=True, text=True, timeout=180)
+                if r.returncode == 0:
+                    console.print("   ✅ Java installed")
+                    return shutil.which("java") is not None
+                else:
+                    console.print(f"   ⚠️  Install may have failed: {r.stderr[-200:]}")
+                    return False
+            
+        elif sys.platform == "darwin":
+            # macOS — try Homebrew
+            brew = shutil.which("brew")
+            if not brew:
+                console.print("   Homebrew not found. Attempting to install Homebrew...")
+                console.print("   [yellow]This may take a few minutes.[/]")
+                r = subprocess.run([
+                    "/bin/bash", "-c",
+                    "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
+                ], capture_output=True, text=True, timeout=300)
+                if r.returncode == 0:
+                    brew = shutil.which("brew") or "/opt/homebrew/bin/brew"
+                    console.print("   ✅ Homebrew installed")
+                else:
+                    console.print(f"   ⚠️  Homebrew install failed: {r.stderr[-200:]}")
+                    return False
+            
+            if brew:
+                console.print(f"   Running: {brew} install openjdk@21")
+                r = subprocess.run([brew, "install", "openjdk@21"],
+                                 capture_output=True, text=True, timeout=300)
+                if r.returncode == 0:
+                    console.print("   ✅ Java installed via Homebrew")
+                    return shutil.which("java") is not None
+                else:
+                    console.print(f"   ⚠️  Install issue: {r.stderr[-200:]}")
+                    return False
+                    
+        elif sys.platform == "win32":
+            # Windows — try Chocolatey, then winget
+            choco = shutil.which("choco") or shutil.which("choco.exe")
+            
+            if not choco:
+                console.print("   Chocolatey not found. Attempting to install...")
+                console.print("   [yellow](requires PowerShell as Administrator)[/]")
+                ps_cmd = (
+                    "Set-ExecutionPolicy Bypass -Scope Process -Force; "
+                    "[System.Net.ServicePointManager]::SecurityProtocol = "
+                    "[System.Net.ServicePointManager]::SecurityProtocol -bor 3072; "
+                    "iex ((New-Object System.Net.WebClient).DownloadString("
+                    "'https://chocolatey.org/install.ps1'))"
+                )
+                r = subprocess.run(["powershell", "-NoProfile", "-Command", ps_cmd],
+                                 capture_output=True, text=True, timeout=120)
+                if r.returncode == 0:
+                    choco = shutil.which("choco") or shutil.which("choco.exe")
+                    console.print("   ✅ Chocolatey installed")
+                else:
+                    console.print(f"   ⚠️  Chocolatey install failed: {r.stderr[-200:]}")
+                    # Try winget as fallback
+                    winget = shutil.which("winget") or shutil.which("winget.exe")
+                    if winget:
+                        console.print("   Trying winget instead...")
+                        r = subprocess.run([winget, "install", "--id", "Amazon.Corretto.21", "--accept-package-agreements"],
+                                         capture_output=True, text=True, timeout=120)
+                        if r.returncode == 0:
+                            console.print("   ✅ Java installed via winget")
+                            return shutil.which("java") is not None
+                    return False
+            
+            if choco:
+                console.print(f"   Running: choco install openjdk21")
+                r = subprocess.run([choco, "install", "openjdk21", "-y"],
+                                 capture_output=True, text=True, timeout=180)
+                if r.returncode == 0:
+                    console.print("   ✅ Java installed via Chocolatey")
+                    return shutil.which("java") is not None
+                else:
+                    console.print(f"   ⚠️  Install issue: {r.stderr[-200:]}")
+                    return False
+    except Exception as e:
+        console.print(f"   ⚠️  Java install failed: {e}")
+    
+    return False
+
+
+def setup() -> None:
+    """Setup: installs everything possible via Python.
+    
+    What this installs:
+      - Java 17+ (via pkg/apt/brew/choco — may need sudo/admin)
+      - androguard (via pip)
+      - smali, baksmali, APKEditor JARs (via urllib)
+      - Android SDK (if Java is available)
+      
+    Run without arguments for full auto-setup.
+    """
+    import urllib.request
+    import zipfile
+    
+    plat = detect_platform()
+    console.print(f"[bold cyan]📱 APKDev Setup — {plat['platform_name']}[/]")
+    console.print()
+
+    # Step 0: Install Java (if missing)
+    has_java = shutil.which("java") is not None
+    if not has_java:
+        console.print("[bold]Step 0: Install Java 17+[/]")
+        has_java = _install_java(plat)
+        if has_java:
+            console.print("   ✅ Java is ready!")
+        else:
+            console.print("   ⚠️  Could not auto-install Java.")
+            console.print("   Install it manually:")
+            if sys.platform == "win32":
+                console.print("     https://adoptium.net/temurin/releases/  (JDK 21)")
+            elif sys.platform == "darwin":
+                console.print("     brew install openjdk@21")
+            else:
+                console.print("     sudo apt-get install openjdk-21-jdk")
+        console.print()
+
+    # Step 0b: Install Termux build + RE tools (if on Termux)
+    if plat["is_termux"]:
+        console.print("[bold]Step 0b: Android build + RE tools[/]")
+        needed = ["aapt2", "d8", "apksigner", "jadx", "dex2jar"]
+        missing = [t for t in needed if not shutil.which(t)]
+        if missing:
+            console.print(f"   Installing: {' '.join(missing)}")
+            subprocess.run(["pkg", "install", "-y"] + missing,
+                         capture_output=True, timeout=120)
+            for t in missing:
+                if shutil.which(t):
+                    console.print(f"   ✅ {t} installed")
+                else:
+                    console.print(f"   ⚠️  {t} failed")
+        else:
+            console.print("   ✅ All build + RE tools already installed")
+        console.print()
+    else:
+        # Non-Termux: try to install RE tools via platform package manager
+        re_tools = {"linux": ["jadx", "dex2jar"], "darwin": ["jadx", "dex2jar"], "win32": ["jadx", "dex2jar"]}
+        console.print("[bold]Step 0b: Reverse engineering tools[/]")
+        pm = plat.get("pkg_install_cmd", [])
+        if pm:
+            missing = [t for t in re_tools.get(sys.platform, []) if not shutil.which(t)]
+            if missing:
+                console.print(f"   Installing: {' '.join(missing)}")
+                try:
+                    subprocess.run(pm + missing, capture_output=True, timeout=120)
+                    for t in missing:
+                        if shutil.which(t):
+                            console.print(f"   ✅ {t} installed")
+                except:
+                    console.print(f"   ⚠️  Try: sudo apt-get install jadx dex2jar")
+            else:
+                console.print("   ✅ RE tools already installed")
+        console.print()
+
+    python_bin_dir = Path(shutil.which("python3") or sys.executable).parent
+
+    # Step 1: smali/baksmali (Java JARs)
+    console.print("[bold]Step 1: smali/baksmali (JARs)[/]")
+    for name, jar_path, url in [
+        ("smali", Path.home() / ".smali.jar",
+         "https://bitbucket.org/JesusFreke/smali/downloads/smali-2.5.2.jar"),
+        ("baksmali", Path.home() / ".baksmali.jar",
+         "https://bitbucket.org/JesusFreke/smali/downloads/baksmali-2.5.2.jar"),
+    ]:
+        if not jar_path.exists():
+            console.print(f"   Downloading {name} 2.5.2...")
+            if _download_jar(url, jar_path):
+                _create_wrapper(python_bin_dir / name, name)
+                console.print(f"   ✅ {name} installed")
+            else:
+                console.print(f"   ⚠️  {name} download failed")
+        else:
+            console.print(f"   ✅ {name} already installed")
+
+    # Step 2: APKEditor
+    console.print("[bold]Step 2: APKEditor (JAR)[/]")
+    apkeditor_jar = Path.home() / ".APKEditor.jar"
+    if not apkeditor_jar.exists() or apkeditor_jar.stat().st_size < 1000:
+        console.print("   Downloading APKEditor 1.4.9...")
+        if _download_jar(
+            "https://github.com/REAndroid/APKEditor/releases/download/V1.4.9/APKEditor-1.4.9.jar",
+            apkeditor_jar
+        ):
+            _create_wrapper(python_bin_dir / "apkeditor", "APKEditor")
+            console.print("   ✅ APKEditor installed")
+        else:
+            console.print("   ⚠️  Download failed")
+    else:
+        console.print("   ✅ APKEditor already installed")
+
+    # Step 3: androguard (Python package)
+    console.print("[bold]Step 3: Python packages[/]")
+    try:
+        import androguard
+        console.print(f"   ✅ androguard {androguard.__version__} already")
+    except ImportError:
+        console.print("   Installing androguard via pip...")
+        try:
+            subprocess.run(
+                [sys.executable, "-m", "pip", "install", "androguard"],
+                capture_output=True, timeout=120
+            )
+            console.print("   ✅ androguard installed")
+        except Exception:
+            console.print("   ⚠️  pip install failed, try: pip3 install androguard")
+
+    # Step 4: Android SDK
+    console.print("[bold]Step 4: Android SDK (for building)[/]")
+    sdk_dir = Path.home() / "android-sdk"
+    sdk_done = (sdk_dir / "platforms" / "android-34").exists()
+    has_java = shutil.which("java") is not None  # Re-check after possible install
+
+    if not sdk_done and has_java:
+        console.print("   Setting up Android SDK...")
+        sdk_dir.mkdir(parents=True, exist_ok=True)
+        
+        zip_path = Path.home() / "cmdline-tools.zip"
+        if not zip_path.exists():
+            console.print("   Downloading SDK tools (~150 MB)...")
+            try:
+                urllib.request.urlretrieve(
+                    "https://dl.google.com/android/repository/commandlinetools-linux-11076708_latest.zip",
+                    str(zip_path)
+                )
+            except Exception as e:
+                console.print(f"   ⚠️  Download failed: {e}")
+        
+        if zip_path.exists() and zip_path.stat().st_size > 1000:
+            with zipfile.ZipFile(str(zip_path), "r") as zf:
+                zf.extractall(str(sdk_dir))
+            
+            cmdline_dir = sdk_dir / "cmdline-tools"
+            latest_dir = cmdline_dir / "latest"
+            if not latest_dir.exists():
+                latest_dir.mkdir(parents=True, exist_ok=True)
+                # Move bin/, lib/ etc. into latest/
+                for item in cmdline_dir.iterdir():
+                    if item.name != "latest" and item.name != ".." and item.name != ".":
+                        dest = latest_dir / item.name
+                        if not dest.exists():
+                            item.rename(dest)
+            sdkmanager = latest_dir / "bin" / "sdkmanager"
+            if sdkmanager.exists():
+                os.environ["ANDROID_HOME"] = str(sdk_dir)
+                # Ensure executable
+                sdkmanager.chmod(0o755)
+                sdk_root_arg = f"--sdk_root={sdk_dir}"
+                console.print("   Accepting SDK licenses...")
+                subprocess.run([str(sdkmanager), sdk_root_arg, "--licenses"],
+                              input=b"y\ny\ny\ny\ny\n", capture_output=True, timeout=30)
+                console.print("   Installing android-34...")
+                r = subprocess.run([str(sdkmanager), sdk_root_arg, "platforms;android-34"],
+                                 capture_output=True, timeout=300)
+                if r.returncode == 0:
+                    console.print("   ✅ Android SDK installed")
+                    sdk_done = True
+                else:
+                    console.print(f"   ⚠️  SDK issue: {r.stderr[-200:].decode()}")
+    elif sdk_done:
+        console.print("   ✅ Android SDK already installed")
+    elif not has_java:
+        console.print("   ⚠️  Java needed for SDK")
+
+    # Step 5: Debug keystore
+    console.print("[bold]Step 5: Debug keystore[/]")
+    keystore = Path.home() / ".android" / "debug.keystore"
+    if not keystore.exists() and has_java:
+        console.print("   Creating debug keystore...")
+        keystore.parent.mkdir(parents=True, exist_ok=True)
+        try:
+            subprocess.run(["keytool", "-genkey", "-v", "-keystore", str(keystore),
+                "-storepass", "android", "-alias", "androiddebugkey",
+                "-keypass", "android", "-keyalg", "RSA", "-keysize", "2048",
+                "-validity", "10000",
+                "-dname", "CN=Android Debug,O=Android,C=US"],
+                capture_output=True, timeout=15)
+            console.print("   ✅ Debug keystore created")
+        except Exception:
+            console.print("   ⚠️  keytool not available")
+    elif keystore.exists():
+        console.print("   ✅ Debug keystore exists")
+
+    # Summary
+    has_java = shutil.which("java") is not None
+    console.print()
+    console.print("[bold green]══════════════════════════════════════[/]")
+    console.print("[bold green]  Setup complete![/]")
+    console.print("[bold green]══════════════════════════════════════[/]")
+    console.print()
+    console.print(f"  {'✅' if has_java else '❌'} Java     — {'installed' if has_java else 'install manually'}")
+    console.print(f"  {'✅' if sdk_done else '❌'} SDK      — {'installed' if sdk_done else 'needs Java'}")
+    console.print(f"  ✅ apkdev — always ready (pure Python)")
+    console.print()
+    console.print("  [bold]Commands without Java:[/] ls, extract, new, info, doctor")
+    if not has_java:
+        console.print()
+        console.print("  [yellow]To install Java manually:[/]")
+        if sys.platform == "win32":
+            console.print("    https://adoptium.net/temurin/releases/")
+        elif sys.platform == "darwin":
+            console.print("    brew install openjdk@21")
+        elif plat["is_termux"]:
+            console.print("    pkg install openjdk-21")
+        else:
+            console.print("    sudo apt-get install openjdk-21-jdk")
+    console.print()
+    if has_java and not sdk_done:
+        console.print("[yellow]Re-run after Java install: apkdev setup[/]")

apkdev/utils.py

@@ -0,0 +1,74 @@
+"""Utilities: subprocess helpers, env, path resolution."""
+
+import os
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+ANDROID_HOME = Path.home() / "android-sdk"
+APKDEV_HOME = Path.home() / ".pi-tui"
+
+
+def check_tool(name: str, hint: str = "") -> str:
+    """Return path to a tool, or raise if not found."""
+    path = shutil.which(name)
+    if path:
+        return path
+    msg = f"❌ '{name}' not found. "
+    if name == "java":
+        msg += "Java is required. Install JDK 17+ from https://adoptium.net"
+    elif name == "aapt2":
+        msg += "Install: pkg install aapt2 (Termux) or sudo apt-get install aapt2"
+    elif name == "apktool":
+        msg += "Install: pkg install apktool (Termux) or sudo apt-get install apktool"
+    elif name == "jadx":
+        msg += "Install: pkg install jadx (Termux) or sudo apt-get install jadx"
+    else:
+        msg += hint or f"Install the '{name}' package for your OS"
+    raise FileNotFoundError(msg)
+
+
+def run(cmd: list[str], **kwargs) -> subprocess.CompletedProcess:
+    """Run a command with nice error handling."""
+    try:
+        return subprocess.run(cmd, check=True, **kwargs)
+    except subprocess.CalledProcessError as e:
+        print(f"⚠️  Command failed: {' '.join(cmd)}", file=sys.stderr)
+        sys.exit(e.returncode)
+
+
+def run_java(jar: str, args: list[str], **kwargs) -> subprocess.CompletedProcess:
+    """Run a Java JAR."""
+    java = check_tool("java")
+    return run([java, "-jar", jar] + args, **kwargs)
+
+
+def ensure_android_home():
+    """Set ANDROID_HOME if not already set."""
+    if "ANDROID_HOME" not in os.environ:
+        os.environ["ANDROID_HOME"] = str(ANDROID_HOME)
+    if "ANDROID_SDK_ROOT" not in os.environ:
+        os.environ["ANDROID_SDK_ROOT"] = str(ANDROID_HOME)
+
+
+def is_termux() -> bool:
+    """Check if we're running inside Termux on Android."""
+    return "TERMUX_VERSION" in os.environ or os.environ.get("ANDROID_ROOT") == "/system"
+
+
+def is_android() -> bool:
+    """Check if we're running on Android."""
+    return os.environ.get("ANDROID_ROOT") == "/system" or os.uname().sysname == "Linux" and os.uname().release.find("android") >= 0
+
+
+def banner():
+    """Return a nice ascii banner."""
+    from rich.panel import Panel
+    from rich.text import Text
+    text = Text()
+    text.append("  ╔══════════════════════════════════╗\n")
+    text.append("  ║     📱  APKDev  v2.0             ║\n")
+    text.append("  ║  Build · Reverse · Engineer      ║\n")
+    text.append("  ╚══════════════════════════════════╝\n")
+    return Panel(text, style="bold cyan", border_style="cyan")