apkdev 2.0.0__py3-none-any.whl

apkdev/completion.py

@@ -0,0 +1,14 @@
+"""Shell completion setup for apkdev."""
+
+import click
+from pathlib import Path
+
+@click.command("completion")
+@click.argument("shell", type=click.Choice(["bash", "zsh", "fish"]), default="bash")
+def completion(shell):
+    """Generate shell completion script."""
+    from .cli import cli
+    script = cli.shell_complete(click.Context(cli), shell)
+    print(f"# Add to ~/.bashrc or ~/.{shell}rc:")
+    print(script)
+

apkdev/device.py

@@ -0,0 +1,161 @@
+"""Device commands — install, uninstall, pull APKs, list devices via ADB."""
+
+import subprocess
+from pathlib import Path
+from typing import Optional
+
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+
+from .utils import check_tool
+
+console = Console()
+
+
+def _adb_devices() -> list[dict]:
+    """Return list of connected devices."""
+    adb = check_tool("adb")
+    r = subprocess.run([adb, "devices", "-l"], capture_output=True, text=True, timeout=10)
+    lines = r.stdout.strip().split("\n")
+    devices = []
+    for line in lines[1:]:  # skip "List of devices attached"
+        parts = line.strip().split()
+        if not parts or len(parts) < 2:
+            continue
+        device = {"id": parts[0], "status": parts[1]}
+        # Parse -l fields
+        extra = " ".join(parts[2:]) if len(parts) > 2 else ""
+        if "product:" in extra:
+            for token in extra.split():
+                if ":" in token:
+                    k, v = token.split(":", 1)
+                    device[k] = v
+        devices.append(device)
+    return devices
+
+
+def devices() -> None:
+    """List connected Android devices."""
+    devs = _adb_devices()
+    if not devs:
+        console.print("[yellow]No devices connected[/]")
+        console.print("  Enable USB debugging and connect your phone.")
+        return
+
+    t = Table(title=f"Devices ({len(devs)})", border_style="cyan")
+    t.add_column("Device ID")
+    t.add_column("Status")
+    t.add_column("Product")
+    t.add_column("Model")
+
+    for d in devs:
+        status_color = "green" if d["status"] == "device" else "red"
+        t.add_row(
+            d["id"],
+            f"[{status_color}]{d['status']}[/]",
+            d.get("product", ""),
+            d.get("model", ""),
+        )
+    console.print(t)
+
+
+def install_apk(apk: str, serial: Optional[str] = None) -> None:
+    """Install APK to device via ADB."""
+    apk_path = Path(apk)
+    if not apk_path.exists():
+        console.print(f"[red]❌ File not found: {apk}[/]")
+        return
+
+    adb = check_tool("adb")
+    cmd = [adb]
+    if serial:
+        cmd += ["-s", serial]
+    cmd += ["install", "-r", "-t", apk]
+
+    console.print(f"[yellow]📲 Installing {apk_path.name}...[/]")
+    r = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
+
+    if r.returncode == 0:
+        console.print("[green]✅ Installed successfully![/]")
+    else:
+        console.print(f"[red]❌ Install failed[/]")
+        console.print(f"[dim]{r.stderr}[/]")
+
+
+def uninstall(package: str, serial: Optional[str] = None) -> None:
+    """Uninstall a package from device."""
+    adb = check_tool("adb")
+    cmd = [adb]
+    if serial:
+        cmd += ["-s", serial]
+    cmd += ["uninstall", package]
+
+    console.print(f"[yellow]🗑️  Uninstalling {package}...[/]")
+    r = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
+
+    if r.returncode == 0:
+        console.print(f"[green]✅ Uninstalled {package}[/]")
+    else:
+        console.print(f"[red]❌ Failed: {r.stderr.strip()}[/]")
+
+
+def pull_apk(package: str, output: Optional[str] = None, serial: Optional[str] = None) -> None:
+    """Pull APK from a device by package name."""
+    adb = check_tool("adb")
+
+    # Get APK path on device
+    prefix = [adb]
+    if serial:
+        prefix += ["-s", serial]
+
+    r = subprocess.run(prefix + ["shell", "pm", "path", package],
+                       capture_output=True, text=True, timeout=10)
+    if r.returncode != 0 or "package:" not in r.stdout:
+        console.print(f"[red]❌ Package '{package}' not found on device[/]")
+        console.print(f"[dim]{r.stderr}[/]")
+        return
+
+    remote_path = r.stdout.strip().split("package:")[-1].strip()
+
+    dest = output or f"{package}.apk"
+
+    console.print(f"[yellow]📥 Pulling {remote_path} → {dest}...[/]")
+    r2 = subprocess.run(prefix + ["pull", remote_path, dest],
+                        capture_output=True, text=True, timeout=30)
+
+    if r2.returncode == 0:
+        size = Path(dest).stat().st_size if Path(dest).exists() else 0
+        from rich.text import Text
+        console.print(f"[green]✅ Pulled → {dest}[/] [dim]({size/1024/1024:.1f} MB)[/]")
+    else:
+        console.print(f"[red]❌ Failed: {r2.stderr.strip()}[/]")
+
+
+def list_packages(serial: Optional[str] = None, filter_str: Optional[str] = None) -> None:
+    """List installed packages on device."""
+    adb = check_tool("adb")
+    cmd = [adb]
+    if serial:
+        cmd += ["-s", serial]
+    cmd += ["shell", "pm", "list", "packages"]
+    if filter_str:
+        cmd += ["|", "grep", filter_str]
+
+    import shlex
+    shell_cmd = " ".join(shlex.quote(c) for c in cmd)
+
+    r = subprocess.run(shell_cmd, capture_output=True, text=True, timeout=15, shell=True)
+    if r.returncode != 0:
+        console.print(f"[red]❌ Failed to list packages[/]")
+        return
+
+    pkgs = [l.replace("package:", "").strip() for l in r.stdout.strip().split("\n") if l.strip()]
+    pkgs.sort()
+
+    t = Table(title=f"Packages ({len(pkgs)})", border_style="cyan")
+    t.add_column("#", style="dim")
+    t.add_column("Package")
+    for i, p in enumerate(pkgs, 1):
+        t.add_row(str(i), p)
+    console.print(t)

apkdev/inspector.py

@@ -0,0 +1,291 @@
+"""APK Inspector — extract metadata, manifest, permissions, strings from APKs."""
+
+import subprocess
+from pathlib import Path
+
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from rich.syntax import Syntax
+
+from .utils import check_tool
+
+console = Console()
+
+
+def _run_aapt(cmd: list[str]) -> str:
+    """Run aapt2 dump subcommand and return output."""
+    aapt = check_tool("aapt2")
+    try:
+        r = subprocess.run([aapt, "dump"] + cmd, capture_output=True, text=True, timeout=15)
+        return r.stdout
+    except subprocess.TimeoutExpired:
+        return "⚠️  Timed out"
+    except FileNotFoundError:
+        return "❌ aapt2 not found"
+
+
+def inspect(apk: str) -> None:
+    """Full APK inspection — package, version, permissions, activities, services, etc."""
+    apk_path = Path(apk)
+    if not apk_path.exists():
+        console.print(f"[red]❌ File not found: {apk}[/]")
+        return
+
+    raw = _run_aapt(["badging", apk])
+
+    if not raw or "ERROR" in raw.upper():
+        console.print(f"[red]❌ Could not parse APK: {apk}[/]")
+        console.print(f"[dim]{raw}[/]")
+        return
+
+    # Parse the badging output
+    lines = raw.split("\n")
+
+    # Extract fields
+    package = ""
+    version_name = ""
+    version_code = ""
+    min_sdk = ""
+    target_sdk = ""
+    app_label = ""
+    icon = ""
+    compile_sdk = ""
+    platform_build = ""
+
+    for line in lines:
+        # Skip comments and empty
+        if not line.strip():
+            continue
+
+        if line.startswith("package:"):
+            # package: name='com.example.app' versionCode='1' versionName='1.0' compileSdkVersion='35'
+            import re
+            m = re.search(r"name='([^']+)'", line)
+            if m: package = m.group(1)
+            m = re.search(r"versionCode='([^']+)'", line)
+            if m: version_code = m.group(1)
+            m = re.search(r"versionName='([^']+)'", line)
+            if m: version_name = m.group(1)
+            m = re.search(r"compileSdkVersion='([^']+)'", line)
+            if m: compile_sdk = m.group(1)
+            m = re.search(r"platformBuildVersionName='([^']+)'", line)
+            if m: platform_build = m.group(1)
+
+        elif line.startswith("sdkVersion:"):
+            min_sdk = line.split(":")[1].strip().strip("'")
+        elif line.startswith("targetSdkVersion:"):
+            target_sdk = line.split(":")[1].strip().strip("'")
+        elif line.startswith("application-label:"):
+            app_label = line.split(":")[1].strip().strip("'")
+        elif line.startswith("application-icon-"):
+            icon = line.split(":")[1].strip().strip("'")
+
+    # ─── Print Info Panel ───
+    from rich.text import Text
+    from rich.layout import Layout
+
+    info = Text()
+    info.append(f"\n  📦 {package}", style="bold cyan")
+    if app_label:
+        info.append(f"\n  🏷️  {app_label}")
+    info.append(f"\n")
+    info.append(f"\n  Version:  {version_name}  (code {version_code})")
+    info.append(f"\n  SDK:      min {min_sdk}  /  target {target_sdk}")
+    if compile_sdk:
+        info.append(f"\n  Compile:  SDK {compile_sdk}")
+    if platform_build:
+        info.append(f"\n  Build:    {platform_build}")
+
+    console.print(Panel(info, border_style="cyan", title="APK Info"))
+
+    # ─── Permissions Table ───
+    perms = [l.split(":")[1].strip().strip("'") for l in lines if l.startswith("uses-permission:")]
+    if perms:
+        t = Table(title=f"Permissions ({len(perms)})", border_style="yellow")
+        t.add_column("#", style="dim")
+        t.add_column("Permission")
+        for i, p in enumerate(perms, 1):
+            name = p.split(".")[-1] if "." in p else p
+            t.add_row(str(i), f"[yellow]{name}[/]\n[dim]{p}[/]")
+        console.print(t)
+    else:
+        console.print("[dim]No permissions[/]")
+
+    # ─── Activities Table ───
+    activities = []
+    for line in lines:
+        if line.startswith("activity:"):
+            import re
+            m = re.search(r"name='([^']+)'", line)
+            if m:
+                activities.append(m.group(1))
+
+    if activities:
+        t = Table(title=f"Activities ({len(activities)})", border_style="green")
+        t.add_column("#", style="dim")
+        t.add_column("Activity")
+        t.add_column("Launcher", style="cyan")
+        for i, act in enumerate(activities, 1):
+            is_launcher = "launchable-activity" in raw and act in raw
+            t.add_row(str(i), act, "🏠" if is_launcher else "")
+        console.print(t)
+
+    # ─── Services / Receivers / Providers ───
+    for kind, label, color in [
+        ("service:", "Services", "magenta"),
+        ("receiver:", "Receivers", "blue"),
+        ("provider:", "Providers", "purple"),
+    ]:
+        items = []
+        for line in lines:
+            if line.startswith(kind):
+                import re
+                m = re.search(r"name='([^']+)'", line)
+                if m:
+                    items.append(m.group(1))
+        if items:
+            t = Table(title=f"{label} ({len(items)})", border_style=color)
+            t.add_column("#", style="dim")
+            t.add_column("Name")
+            for i, item in enumerate(items, 1):
+                t.add_row(str(i), item)
+            console.print(t)
+
+    # ─── Feature table ───
+    features = [l.split(":")[1].strip().strip("'") for l in lines if l.startswith("uses-feature:")]
+    if features:
+        t = Table(title=f"Features ({len(features)})", border_style="cyan")
+        t.add_column("#", style="dim")
+        t.add_column("Feature")
+        for i, f in enumerate(features, 1):
+            t.add_row(str(i), f)
+        console.print(t)
+
+    # ─── Supported screens ───
+    screens = [l.split(":")[1].strip().strip("'") for l in lines if l.startswith("supports-screens:")]
+    if screens:
+        console.print(f"\n[bold]Screens:[/] {', '.join(screens)}")
+
+
+def manifest(apk: str) -> None:
+    """Extract and display AndroidManifest.xml."""
+    raw = _run_aapt(["xmltree", apk, "--file", "AndroidManifest.xml"])
+    if raw:
+        syntax = Syntax(raw, "xml", theme="monokai", line_numbers=True)
+        console.print(Panel(syntax, border_style="green", title="AndroidManifest.xml"))
+    else:
+        console.print("[red]❌ Could not extract manifest[/]")
+
+
+def permissions(apk: str) -> None:
+    """List all permissions from APK."""
+    raw = _run_aapt(["permissions", apk])
+    if raw:
+        lines = [l for l in raw.split("\n") if l.strip()]
+        t = Table(title=f"Permissions ({len(lines)})", border_style="yellow")
+        t.add_column("#", style="dim")
+        t.add_column("Permission")
+        for i, p in enumerate(lines, 1):
+            t.add_row(str(i), p)
+        console.print(t)
+    else:
+        console.print("[dim]No permissions found[/]")
+
+
+def strings(apk: str) -> None:
+    """Extract resource string pool from APK."""
+    raw = _run_aapt(["strings", apk])
+    if raw:
+        lines = [l for l in raw.split("\n") if l.strip()]
+        # Show first 200 strings
+        MAX = 200
+        preview = lines[:MAX]
+        t = Table(title=f"Resource Strings ({len(lines)} total, showing {len(preview)})",
+                  border_style="blue")
+        t.add_column("#", style="dim")
+        t.add_column("String")
+        for i, s in enumerate(preview, 1):
+            # Truncate long strings
+            display = s[:120] + "..." if len(s) > 120 else s
+            t.add_row(str(i), display)
+        console.print(t)
+    else:
+        console.print("[dim]No strings found[/]")
+
+
+def resources(apk: str) -> None:
+    """List resource table from APK."""
+    raw = _run_aapt(["resources", apk])
+    if raw:
+        lines = [l for l in raw.split("\n") if l.strip()]
+        MAX = 300
+        preview = lines[:MAX]
+        t = Table(title=f"Resources ({len(lines)} total, showing {len(preview)})",
+                  border_style="magenta")
+        t.add_column("#", style="dim")
+        t.add_column("Resource")
+        for i, r in enumerate(preview, 1):
+            t.add_row(str(i), r[:150])
+        console.print(t)
+    else:
+        console.print("[dim]No resources found[/]")
+
+
+def analyze(apk: str) -> None:
+    """Deep analysis of APK. Uses androguard if available, falls back to aapt2."""
+    apk_path = Path(apk)
+    if not apk_path.exists():
+        console.print(f"[red]\u274c File not found: {apk}[/]")
+        return
+
+    # Try androguard first
+    try:
+        import androguard
+        from androguard.misc import AnalyzeAPK
+        
+        console.print(f"[yellow]\U0001f50d Analyzing {apk} with androguard...[/]")
+        try:
+            a, _, _ = AnalyzeAPK(apk)
+        except Exception as e:
+            console.print(f"[red]\u274c androguard error: {e}[/]")
+            console.print("[yellow]Falling back to aapt2...[/]")
+            inspect(apk)
+            return
+
+        console.print(f"\n[bold cyan]\U0001f4e6 {a.get_package()}[/]")
+        console.print(f"  Version: {a.get_androidversion_name()} (code {a.get_androidversion_code()})")
+
+        perms = a.get_permissions()
+        if perms:
+            t = Table(title=f"Permissions ({len(perms)})", border_style="yellow")
+            t.add_column("Permission")
+            for p in perms:
+                t.add_row(p)
+            console.print(t)
+
+        for name, items, icon in [
+            ("Activities", a.get_activities(), "\U0001f3e0"),
+            ("Services", a.get_services(), "\u2699"),
+            ("Receivers", a.get_receivers(), "\U0001f4e1"),
+            ("Providers", a.get_providers(), "\U0001f4cb"),
+        ]:
+            if items:
+                console.print(f"\n[bold]{icon} {name} ({len(items)}):[/]")
+                for item in items:
+                    console.print(f"    \u2022 {item}")
+
+        main = a.get_main_activity()
+        if main:
+            console.print(f"  \U0001f3e0 [cyan]Main:[/] {main}")
+
+        console.print(f"\n[bold]SDK:[/] min={a.get_min_sdk_version()}  target={a.get_target_sdk_version()}  max={a.get_max_sdk_version()}")
+        sigs = a.get_signatures()
+        if sigs:
+            console.print(f"\n[bold]Signatures:[/] {len(sigs)}")
+            for sig in sigs[:3]:
+                console.print(f"    \u2022 {sig[:64]}...")
+
+    except ImportError:
+        console.print("[yellow]\U0001f50d Using aapt2-based analysis (install androguard for deeper: pip3 install androguard)[/]")
+        inspect(apk)

apkdev/optimizer.py

@@ -0,0 +1,58 @@
+"""Optimize — zipalign + sign APK in one step."""
+
+import subprocess
+from pathlib import Path
+
+from rich.console import Console
+
+from .utils import check_tool
+
+console = Console()
+
+
+def optimize(apk_path: str) -> None:
+    """Zipalign + sign an APK."""
+    apk = Path(apk_path)
+    if not apk.exists():
+        console.print(f"[red]❌ File not found: {apk}[/]")
+        return
+
+    aligned = apk.parent / f"{apk.stem}-aligned.apk"
+    zipalign = check_tool("zipalign")
+    apksigner = check_tool("apksigner")
+    keystore = Path.home() / ".android" / "debug.keystore"
+
+    # Step 1: Zipalign
+    console.print(f"[yellow]🔧 Zipaligning → {aligned.name}...[/]")
+    r1 = subprocess.run([zipalign, "-f", "-p", "4", str(apk), str(aligned)],
+                        capture_output=True, text=True, timeout=30)
+    if r1.returncode != 0:
+        console.print(f"[red]❌ Zipalign failed: {r1.stderr}[/]")
+        return
+
+    # Step 2: Sign
+    if not keystore.exists():
+        console.print("[yellow]🔑 Creating debug keystore...[/]")
+        keytool = check_tool("keytool")
+        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(f"[yellow]🔑 Signing {aligned.name}...[/]")
+    r2 = subprocess.run([
+        apksigner, "sign", "--ks", str(keystore),
+        "--ks-key-alias", "androiddebugkey",
+        "--ks-pass", "pass:android",
+        "--key-pass", "pass:android",
+        str(aligned),
+    ], capture_output=True, text=True, timeout=30)
+
+    if r2.returncode == 0:
+        size_mb = aligned.stat().st_size / 1024 / 1024
+        console.print(f"[green]✅ Optimized → {aligned}[/] [dim]({size_mb:.1f} MB)[/]")
+    else:
+        console.print(f"[red]❌ Signing failed: {r2.stderr}[/]")

apkdev/reverser.py

@@ -0,0 +1,62 @@
+"""Reverse Engineering tools — apktool, jadx, smali, dex2jar, APKEditor."""
+
+from pathlib import Path
+
+from .utils import check_tool, run, run_java
+
+
+# ─── Known JARs ──────────────────────────────────────────────
+SMALI_JAR = Path.home() / ".smali.jar"
+BAKSMALI_JAR = Path.home() / ".baksmali.jar"
+APKEDITOR_JAR = Path.home() / ".APKEditor.jar"
+
+
+def apktool_decode(apk: str, output: str | None = None) -> None:
+    """Decode APK with apktool."""
+    apktool = check_tool("apktool")
+    out = output or apk.replace(".apk", "")
+    run([apktool, "d", apk, "-o", out, "--force"])
+    print(f"✅ Decoded → {out}/")
+
+
+def apktool_rebuild(directory: str, output: str | None = None) -> None:
+    """Rebuild APK from decoded directory."""
+    apktool = check_tool("apktool")
+    out = output or f"{directory.rstrip('/')}.apk"
+    run([apktool, "b", directory, "-o", out])
+    print(f"✅ Rebuilt → {out}")
+
+
+def jadx_decompile(target: str, output: str | None = None) -> None:
+    """Decompile DEX/APK to Java source with jadx."""
+    jadx = check_tool("jadx")
+    out = output or f"{Path(target).stem}-source"
+    run([jadx, "-d", out, target])
+    print(f"✅ Java source → {out}/")
+
+
+def smali_assemble(smali_dir: str, output: str | None = None) -> None:
+    """Assemble smali → dex."""
+    out = output or "out.dex"
+    run_java(str(SMALI_JAR), ["a", smali_dir, "-o", out])
+    print(f"✅ Dex → {out}")
+
+
+def baksmali_disassemble(dex_file: str, output: str | None = None) -> None:
+    """Disassemble dex → smali."""
+    out = output or "smali_out"
+    run_java(str(BAKSMALI_JAR), ["d", dex_file, "-o", out])
+    print(f"✅ Smali → {out}/")
+
+
+def dex2jar(dex_file: str, output: str | None = None) -> None:
+    """Convert DEX/APK to JAR."""
+    d2j = check_tool("d2j-dex2jar")
+    out = output or f"{Path(dex_file).stem}.jar"
+    run([d2j, dex_file, "-o", out])
+    print(f"✅ JAR → {out}")
+
+
+def apkeditor(*args: str) -> None:
+    """Run APKEditor with arbitrary args."""
+    run_java(str(APKEDITOR_JAR), list(args))